c475977de05aa13240292e7ec16ab2fe9789f94a
[linux-2.6.git] / net / sunrpc / svcsock.c
1 /*
2  * linux/net/sunrpc/svcsock.c
3  *
4  * These are the RPC server socket internals.
5  *
6  * The server scheduling algorithm does not always distribute the load
7  * evenly when servicing a single client. May need to modify the
8  * svc_xprt_enqueue procedure...
9  *
10  * TCP support is largely untested and may be a little slow. The problem
11  * is that we currently do two separate recvfrom's, one for the 4-byte
12  * record length, and the second for the actual record. This could possibly
13  * be improved by always reading a minimum size of around 100 bytes and
14  * tucking any superfluous bytes away in a temporary store. Still, that
15  * leaves write requests out in the rain. An alternative may be to peek at
16  * the first skb in the queue, and if it matches the next TCP sequence
17  * number, to extract the record marker. Yuck.
18  *
19  * Copyright (C) 1995, 1996 Olaf Kirch <okir@monad.swb.de>
20  */
21
22 #include <linux/kernel.h>
23 #include <linux/sched.h>
24 #include <linux/errno.h>
25 #include <linux/fcntl.h>
26 #include <linux/net.h>
27 #include <linux/in.h>
28 #include <linux/inet.h>
29 #include <linux/udp.h>
30 #include <linux/tcp.h>
31 #include <linux/unistd.h>
32 #include <linux/slab.h>
33 #include <linux/netdevice.h>
34 #include <linux/skbuff.h>
35 #include <linux/file.h>
36 #include <linux/freezer.h>
37 #include <net/sock.h>
38 #include <net/checksum.h>
39 #include <net/ip.h>
40 #include <net/ipv6.h>
41 #include <net/tcp_states.h>
42 #include <asm/uaccess.h>
43 #include <asm/ioctls.h>
44
45 #include <linux/sunrpc/types.h>
46 #include <linux/sunrpc/clnt.h>
47 #include <linux/sunrpc/xdr.h>
48 #include <linux/sunrpc/svcsock.h>
49 #include <linux/sunrpc/stats.h>
50
51 #define RPCDBG_FACILITY RPCDBG_SVCXPRT
52
53
54 static struct svc_sock *svc_setup_socket(struct svc_serv *, struct socket *,
55                                          int *errp, int flags);
56 static void             svc_udp_data_ready(struct sock *, int);
57 static int              svc_udp_recvfrom(struct svc_rqst *);
58 static int              svc_udp_sendto(struct svc_rqst *);
59 static void             svc_sock_detach(struct svc_xprt *);
60 static void             svc_sock_free(struct svc_xprt *);
61
62 static struct svc_xprt *svc_create_socket(struct svc_serv *, int,
63                                           struct sockaddr *, int, int);
64 #ifdef CONFIG_DEBUG_LOCK_ALLOC
65 static struct lock_class_key svc_key[2];
66 static struct lock_class_key svc_slock_key[2];
67
68 static void svc_reclassify_socket(struct socket *sock)
69 {
70         struct sock *sk = sock->sk;
71         BUG_ON(sock_owned_by_user(sk));
72         switch (sk->sk_family) {
73         case AF_INET:
74                 sock_lock_init_class_and_name(sk, "slock-AF_INET-NFSD",
75                                               &svc_slock_key[0],
76                                               "sk_xprt.xpt_lock-AF_INET-NFSD",
77                                               &svc_key[0]);
78                 break;
79
80         case AF_INET6:
81                 sock_lock_init_class_and_name(sk, "slock-AF_INET6-NFSD",
82                                               &svc_slock_key[1],
83                                               "sk_xprt.xpt_lock-AF_INET6-NFSD",
84                                               &svc_key[1]);
85                 break;
86
87         default:
88                 BUG();
89         }
90 }
91 #else
92 static void svc_reclassify_socket(struct socket *sock)
93 {
94 }
95 #endif
96
97 /*
98  * Release an skbuff after use
99  */
100 static void svc_release_skb(struct svc_rqst *rqstp)
101 {
102         struct sk_buff *skb = rqstp->rq_xprt_ctxt;
103         struct svc_deferred_req *dr = rqstp->rq_deferred;
104
105         if (skb) {
106                 struct svc_sock *svsk =
107                         container_of(rqstp->rq_xprt, struct svc_sock, sk_xprt);
108                 rqstp->rq_xprt_ctxt = NULL;
109
110                 dprintk("svc: service %p, releasing skb %p\n", rqstp, skb);
111                 skb_free_datagram(svsk->sk_sk, skb);
112         }
113         if (dr) {
114                 rqstp->rq_deferred = NULL;
115                 kfree(dr);
116         }
117 }
118
119 union svc_pktinfo_u {
120         struct in_pktinfo pkti;
121         struct in6_pktinfo pkti6;
122 };
123 #define SVC_PKTINFO_SPACE \
124         CMSG_SPACE(sizeof(union svc_pktinfo_u))
125
126 static void svc_set_cmsg_data(struct svc_rqst *rqstp, struct cmsghdr *cmh)
127 {
128         struct svc_sock *svsk =
129                 container_of(rqstp->rq_xprt, struct svc_sock, sk_xprt);
130         switch (svsk->sk_sk->sk_family) {
131         case AF_INET: {
132                         struct in_pktinfo *pki = CMSG_DATA(cmh);
133
134                         cmh->cmsg_level = SOL_IP;
135                         cmh->cmsg_type = IP_PKTINFO;
136                         pki->ipi_ifindex = 0;
137                         pki->ipi_spec_dst.s_addr = rqstp->rq_daddr.addr.s_addr;
138                         cmh->cmsg_len = CMSG_LEN(sizeof(*pki));
139                 }
140                 break;
141
142         case AF_INET6: {
143                         struct in6_pktinfo *pki = CMSG_DATA(cmh);
144
145                         cmh->cmsg_level = SOL_IPV6;
146                         cmh->cmsg_type = IPV6_PKTINFO;
147                         pki->ipi6_ifindex = 0;
148                         ipv6_addr_copy(&pki->ipi6_addr,
149                                         &rqstp->rq_daddr.addr6);
150                         cmh->cmsg_len = CMSG_LEN(sizeof(*pki));
151                 }
152                 break;
153         }
154         return;
155 }
156
157 /*
158  * Generic sendto routine
159  */
160 static int svc_sendto(struct svc_rqst *rqstp, struct xdr_buf *xdr)
161 {
162         struct svc_sock *svsk =
163                 container_of(rqstp->rq_xprt, struct svc_sock, sk_xprt);
164         struct socket   *sock = svsk->sk_sock;
165         int             slen;
166         union {
167                 struct cmsghdr  hdr;
168                 long            all[SVC_PKTINFO_SPACE / sizeof(long)];
169         } buffer;
170         struct cmsghdr *cmh = &buffer.hdr;
171         int             len = 0;
172         int             result;
173         int             size;
174         struct page     **ppage = xdr->pages;
175         size_t          base = xdr->page_base;
176         unsigned int    pglen = xdr->page_len;
177         unsigned int    flags = MSG_MORE;
178         RPC_IFDEBUG(char buf[RPC_MAX_ADDRBUFLEN]);
179
180         slen = xdr->len;
181
182         if (rqstp->rq_prot == IPPROTO_UDP) {
183                 struct msghdr msg = {
184                         .msg_name       = &rqstp->rq_addr,
185                         .msg_namelen    = rqstp->rq_addrlen,
186                         .msg_control    = cmh,
187                         .msg_controllen = sizeof(buffer),
188                         .msg_flags      = MSG_MORE,
189                 };
190
191                 svc_set_cmsg_data(rqstp, cmh);
192
193                 if (sock_sendmsg(sock, &msg, 0) < 0)
194                         goto out;
195         }
196
197         /* send head */
198         if (slen == xdr->head[0].iov_len)
199                 flags = 0;
200         len = kernel_sendpage(sock, rqstp->rq_respages[0], 0,
201                                   xdr->head[0].iov_len, flags);
202         if (len != xdr->head[0].iov_len)
203                 goto out;
204         slen -= xdr->head[0].iov_len;
205         if (slen == 0)
206                 goto out;
207
208         /* send page data */
209         size = PAGE_SIZE - base < pglen ? PAGE_SIZE - base : pglen;
210         while (pglen > 0) {
211                 if (slen == size)
212                         flags = 0;
213                 result = kernel_sendpage(sock, *ppage, base, size, flags);
214                 if (result > 0)
215                         len += result;
216                 if (result != size)
217                         goto out;
218                 slen -= size;
219                 pglen -= size;
220                 size = PAGE_SIZE < pglen ? PAGE_SIZE : pglen;
221                 base = 0;
222                 ppage++;
223         }
224         /* send tail */
225         if (xdr->tail[0].iov_len) {
226                 result = kernel_sendpage(sock, rqstp->rq_respages[0],
227                                              ((unsigned long)xdr->tail[0].iov_base)
228                                                 & (PAGE_SIZE-1),
229                                              xdr->tail[0].iov_len, 0);
230
231                 if (result > 0)
232                         len += result;
233         }
234 out:
235         dprintk("svc: socket %p sendto([%p %Zu... ], %d) = %d (addr %s)\n",
236                 svsk, xdr->head[0].iov_base, xdr->head[0].iov_len,
237                 xdr->len, len, svc_print_addr(rqstp, buf, sizeof(buf)));
238
239         return len;
240 }
241
242 /*
243  * Report socket names for nfsdfs
244  */
245 static int one_sock_name(char *buf, struct svc_sock *svsk)
246 {
247         int len;
248
249         switch(svsk->sk_sk->sk_family) {
250         case AF_INET:
251                 len = sprintf(buf, "ipv4 %s %u.%u.%u.%u %d\n",
252                               svsk->sk_sk->sk_protocol==IPPROTO_UDP?
253                               "udp" : "tcp",
254                               NIPQUAD(inet_sk(svsk->sk_sk)->rcv_saddr),
255                               inet_sk(svsk->sk_sk)->num);
256                 break;
257         default:
258                 len = sprintf(buf, "*unknown-%d*\n",
259                                svsk->sk_sk->sk_family);
260         }
261         return len;
262 }
263
264 int
265 svc_sock_names(char *buf, struct svc_serv *serv, char *toclose)
266 {
267         struct svc_sock *svsk, *closesk = NULL;
268         int len = 0;
269
270         if (!serv)
271                 return 0;
272         spin_lock_bh(&serv->sv_lock);
273         list_for_each_entry(svsk, &serv->sv_permsocks, sk_xprt.xpt_list) {
274                 int onelen = one_sock_name(buf+len, svsk);
275                 if (toclose && strcmp(toclose, buf+len) == 0)
276                         closesk = svsk;
277                 else
278                         len += onelen;
279         }
280         spin_unlock_bh(&serv->sv_lock);
281         if (closesk)
282                 /* Should unregister with portmap, but you cannot
283                  * unregister just one protocol...
284                  */
285                 svc_close_xprt(&closesk->sk_xprt);
286         else if (toclose)
287                 return -ENOENT;
288         return len;
289 }
290 EXPORT_SYMBOL(svc_sock_names);
291
292 /*
293  * Check input queue length
294  */
295 static int svc_recv_available(struct svc_sock *svsk)
296 {
297         struct socket   *sock = svsk->sk_sock;
298         int             avail, err;
299
300         err = kernel_sock_ioctl(sock, TIOCINQ, (unsigned long) &avail);
301
302         return (err >= 0)? avail : err;
303 }
304
305 /*
306  * Generic recvfrom routine.
307  */
308 static int svc_recvfrom(struct svc_rqst *rqstp, struct kvec *iov, int nr,
309                         int buflen)
310 {
311         struct svc_sock *svsk =
312                 container_of(rqstp->rq_xprt, struct svc_sock, sk_xprt);
313         struct msghdr msg = {
314                 .msg_flags      = MSG_DONTWAIT,
315         };
316         int len;
317
318         rqstp->rq_xprt_hlen = 0;
319
320         len = kernel_recvmsg(svsk->sk_sock, &msg, iov, nr, buflen,
321                                 msg.msg_flags);
322
323         dprintk("svc: socket %p recvfrom(%p, %Zu) = %d\n",
324                 svsk, iov[0].iov_base, iov[0].iov_len, len);
325         return len;
326 }
327
328 /*
329  * Set socket snd and rcv buffer lengths
330  */
331 static void svc_sock_setbufsize(struct socket *sock, unsigned int snd,
332                                 unsigned int rcv)
333 {
334 #if 0
335         mm_segment_t    oldfs;
336         oldfs = get_fs(); set_fs(KERNEL_DS);
337         sock_setsockopt(sock, SOL_SOCKET, SO_SNDBUF,
338                         (char*)&snd, sizeof(snd));
339         sock_setsockopt(sock, SOL_SOCKET, SO_RCVBUF,
340                         (char*)&rcv, sizeof(rcv));
341 #else
342         /* sock_setsockopt limits use to sysctl_?mem_max,
343          * which isn't acceptable.  Until that is made conditional
344          * on not having CAP_SYS_RESOURCE or similar, we go direct...
345          * DaveM said I could!
346          */
347         lock_sock(sock->sk);
348         sock->sk->sk_sndbuf = snd * 2;
349         sock->sk->sk_rcvbuf = rcv * 2;
350         sock->sk->sk_userlocks |= SOCK_SNDBUF_LOCK|SOCK_RCVBUF_LOCK;
351         release_sock(sock->sk);
352 #endif
353 }
354 /*
355  * INET callback when data has been received on the socket.
356  */
357 static void svc_udp_data_ready(struct sock *sk, int count)
358 {
359         struct svc_sock *svsk = (struct svc_sock *)sk->sk_user_data;
360
361         if (svsk) {
362                 dprintk("svc: socket %p(inet %p), count=%d, busy=%d\n",
363                         svsk, sk, count,
364                         test_bit(XPT_BUSY, &svsk->sk_xprt.xpt_flags));
365                 set_bit(XPT_DATA, &svsk->sk_xprt.xpt_flags);
366                 svc_xprt_enqueue(&svsk->sk_xprt);
367         }
368         if (sk->sk_sleep && waitqueue_active(sk->sk_sleep))
369                 wake_up_interruptible(sk->sk_sleep);
370 }
371
372 /*
373  * INET callback when space is newly available on the socket.
374  */
375 static void svc_write_space(struct sock *sk)
376 {
377         struct svc_sock *svsk = (struct svc_sock *)(sk->sk_user_data);
378
379         if (svsk) {
380                 dprintk("svc: socket %p(inet %p), write_space busy=%d\n",
381                         svsk, sk, test_bit(XPT_BUSY, &svsk->sk_xprt.xpt_flags));
382                 svc_xprt_enqueue(&svsk->sk_xprt);
383         }
384
385         if (sk->sk_sleep && waitqueue_active(sk->sk_sleep)) {
386                 dprintk("RPC svc_write_space: someone sleeping on %p\n",
387                        svsk);
388                 wake_up_interruptible(sk->sk_sleep);
389         }
390 }
391
392 /*
393  * Copy the UDP datagram's destination address to the rqstp structure.
394  * The 'destination' address in this case is the address to which the
395  * peer sent the datagram, i.e. our local address. For multihomed
396  * hosts, this can change from msg to msg. Note that only the IP
397  * address changes, the port number should remain the same.
398  */
399 static void svc_udp_get_dest_address(struct svc_rqst *rqstp,
400                                      struct cmsghdr *cmh)
401 {
402         struct svc_sock *svsk =
403                 container_of(rqstp->rq_xprt, struct svc_sock, sk_xprt);
404         switch (svsk->sk_sk->sk_family) {
405         case AF_INET: {
406                 struct in_pktinfo *pki = CMSG_DATA(cmh);
407                 rqstp->rq_daddr.addr.s_addr = pki->ipi_spec_dst.s_addr;
408                 break;
409                 }
410         case AF_INET6: {
411                 struct in6_pktinfo *pki = CMSG_DATA(cmh);
412                 ipv6_addr_copy(&rqstp->rq_daddr.addr6, &pki->ipi6_addr);
413                 break;
414                 }
415         }
416 }
417
418 /*
419  * Receive a datagram from a UDP socket.
420  */
421 static int svc_udp_recvfrom(struct svc_rqst *rqstp)
422 {
423         struct svc_sock *svsk =
424                 container_of(rqstp->rq_xprt, struct svc_sock, sk_xprt);
425         struct svc_serv *serv = svsk->sk_xprt.xpt_server;
426         struct sk_buff  *skb;
427         union {
428                 struct cmsghdr  hdr;
429                 long            all[SVC_PKTINFO_SPACE / sizeof(long)];
430         } buffer;
431         struct cmsghdr *cmh = &buffer.hdr;
432         int             err, len;
433         struct msghdr msg = {
434                 .msg_name = svc_addr(rqstp),
435                 .msg_control = cmh,
436                 .msg_controllen = sizeof(buffer),
437                 .msg_flags = MSG_DONTWAIT,
438         };
439
440         if (test_and_clear_bit(XPT_CHNGBUF, &svsk->sk_xprt.xpt_flags))
441             /* udp sockets need large rcvbuf as all pending
442              * requests are still in that buffer.  sndbuf must
443              * also be large enough that there is enough space
444              * for one reply per thread.  We count all threads
445              * rather than threads in a particular pool, which
446              * provides an upper bound on the number of threads
447              * which will access the socket.
448              */
449             svc_sock_setbufsize(svsk->sk_sock,
450                                 (serv->sv_nrthreads+3) * serv->sv_max_mesg,
451                                 (serv->sv_nrthreads+3) * serv->sv_max_mesg);
452
453         clear_bit(XPT_DATA, &svsk->sk_xprt.xpt_flags);
454         skb = NULL;
455         err = kernel_recvmsg(svsk->sk_sock, &msg, NULL,
456                              0, 0, MSG_PEEK | MSG_DONTWAIT);
457         if (err >= 0)
458                 skb = skb_recv_datagram(svsk->sk_sk, 0, 1, &err);
459
460         if (skb == NULL) {
461                 if (err != -EAGAIN) {
462                         /* possibly an icmp error */
463                         dprintk("svc: recvfrom returned error %d\n", -err);
464                         set_bit(XPT_DATA, &svsk->sk_xprt.xpt_flags);
465                 }
466                 svc_xprt_received(&svsk->sk_xprt);
467                 return -EAGAIN;
468         }
469         len = svc_addr_len(svc_addr(rqstp));
470         if (len < 0)
471                 return len;
472         rqstp->rq_addrlen = len;
473         if (skb->tstamp.tv64 == 0) {
474                 skb->tstamp = ktime_get_real();
475                 /* Don't enable netstamp, sunrpc doesn't
476                    need that much accuracy */
477         }
478         svsk->sk_sk->sk_stamp = skb->tstamp;
479         set_bit(XPT_DATA, &svsk->sk_xprt.xpt_flags); /* there may be more data... */
480
481         /*
482          * Maybe more packets - kick another thread ASAP.
483          */
484         svc_xprt_received(&svsk->sk_xprt);
485
486         len  = skb->len - sizeof(struct udphdr);
487         rqstp->rq_arg.len = len;
488
489         rqstp->rq_prot = IPPROTO_UDP;
490
491         if (cmh->cmsg_level != IPPROTO_IP ||
492             cmh->cmsg_type != IP_PKTINFO) {
493                 if (net_ratelimit())
494                         printk("rpcsvc: received unknown control message:"
495                                "%d/%d\n",
496                                cmh->cmsg_level, cmh->cmsg_type);
497                 skb_free_datagram(svsk->sk_sk, skb);
498                 return 0;
499         }
500         svc_udp_get_dest_address(rqstp, cmh);
501
502         if (skb_is_nonlinear(skb)) {
503                 /* we have to copy */
504                 local_bh_disable();
505                 if (csum_partial_copy_to_xdr(&rqstp->rq_arg, skb)) {
506                         local_bh_enable();
507                         /* checksum error */
508                         skb_free_datagram(svsk->sk_sk, skb);
509                         return 0;
510                 }
511                 local_bh_enable();
512                 skb_free_datagram(svsk->sk_sk, skb);
513         } else {
514                 /* we can use it in-place */
515                 rqstp->rq_arg.head[0].iov_base = skb->data +
516                         sizeof(struct udphdr);
517                 rqstp->rq_arg.head[0].iov_len = len;
518                 if (skb_checksum_complete(skb)) {
519                         skb_free_datagram(svsk->sk_sk, skb);
520                         return 0;
521                 }
522                 rqstp->rq_xprt_ctxt = skb;
523         }
524
525         rqstp->rq_arg.page_base = 0;
526         if (len <= rqstp->rq_arg.head[0].iov_len) {
527                 rqstp->rq_arg.head[0].iov_len = len;
528                 rqstp->rq_arg.page_len = 0;
529                 rqstp->rq_respages = rqstp->rq_pages+1;
530         } else {
531                 rqstp->rq_arg.page_len = len - rqstp->rq_arg.head[0].iov_len;
532                 rqstp->rq_respages = rqstp->rq_pages + 1 +
533                         DIV_ROUND_UP(rqstp->rq_arg.page_len, PAGE_SIZE);
534         }
535
536         if (serv->sv_stats)
537                 serv->sv_stats->netudpcnt++;
538
539         return len;
540 }
541
542 static int
543 svc_udp_sendto(struct svc_rqst *rqstp)
544 {
545         int             error;
546
547         error = svc_sendto(rqstp, &rqstp->rq_res);
548         if (error == -ECONNREFUSED)
549                 /* ICMP error on earlier request. */
550                 error = svc_sendto(rqstp, &rqstp->rq_res);
551
552         return error;
553 }
554
555 static void svc_udp_prep_reply_hdr(struct svc_rqst *rqstp)
556 {
557 }
558
559 static int svc_udp_has_wspace(struct svc_xprt *xprt)
560 {
561         struct svc_sock *svsk = container_of(xprt, struct svc_sock, sk_xprt);
562         struct svc_serv *serv = xprt->xpt_server;
563         unsigned long required;
564
565         /*
566          * Set the SOCK_NOSPACE flag before checking the available
567          * sock space.
568          */
569         set_bit(SOCK_NOSPACE, &svsk->sk_sock->flags);
570         required = atomic_read(&svsk->sk_xprt.xpt_reserved) + serv->sv_max_mesg;
571         if (required*2 > sock_wspace(svsk->sk_sk))
572                 return 0;
573         clear_bit(SOCK_NOSPACE, &svsk->sk_sock->flags);
574         return 1;
575 }
576
577 static struct svc_xprt *svc_udp_accept(struct svc_xprt *xprt)
578 {
579         BUG();
580         return NULL;
581 }
582
583 static struct svc_xprt *svc_udp_create(struct svc_serv *serv,
584                                        struct sockaddr *sa, int salen,
585                                        int flags)
586 {
587         return svc_create_socket(serv, IPPROTO_UDP, sa, salen, flags);
588 }
589
590 static struct svc_xprt_ops svc_udp_ops = {
591         .xpo_create = svc_udp_create,
592         .xpo_recvfrom = svc_udp_recvfrom,
593         .xpo_sendto = svc_udp_sendto,
594         .xpo_release_rqst = svc_release_skb,
595         .xpo_detach = svc_sock_detach,
596         .xpo_free = svc_sock_free,
597         .xpo_prep_reply_hdr = svc_udp_prep_reply_hdr,
598         .xpo_has_wspace = svc_udp_has_wspace,
599         .xpo_accept = svc_udp_accept,
600 };
601
602 static struct svc_xprt_class svc_udp_class = {
603         .xcl_name = "udp",
604         .xcl_owner = THIS_MODULE,
605         .xcl_ops = &svc_udp_ops,
606         .xcl_max_payload = RPCSVC_MAXPAYLOAD_UDP,
607 };
608
609 static void svc_udp_init(struct svc_sock *svsk, struct svc_serv *serv)
610 {
611         int one = 1;
612         mm_segment_t oldfs;
613
614         svc_xprt_init(&svc_udp_class, &svsk->sk_xprt, serv);
615         clear_bit(XPT_CACHE_AUTH, &svsk->sk_xprt.xpt_flags);
616         svsk->sk_sk->sk_data_ready = svc_udp_data_ready;
617         svsk->sk_sk->sk_write_space = svc_write_space;
618
619         /* initialise setting must have enough space to
620          * receive and respond to one request.
621          * svc_udp_recvfrom will re-adjust if necessary
622          */
623         svc_sock_setbufsize(svsk->sk_sock,
624                             3 * svsk->sk_xprt.xpt_server->sv_max_mesg,
625                             3 * svsk->sk_xprt.xpt_server->sv_max_mesg);
626
627         /* data might have come in before data_ready set up */
628         set_bit(XPT_DATA, &svsk->sk_xprt.xpt_flags);
629         set_bit(XPT_CHNGBUF, &svsk->sk_xprt.xpt_flags);
630
631         oldfs = get_fs();
632         set_fs(KERNEL_DS);
633         /* make sure we get destination address info */
634         svsk->sk_sock->ops->setsockopt(svsk->sk_sock, IPPROTO_IP, IP_PKTINFO,
635                                        (char __user *)&one, sizeof(one));
636         set_fs(oldfs);
637 }
638
639 /*
640  * A data_ready event on a listening socket means there's a connection
641  * pending. Do not use state_change as a substitute for it.
642  */
643 static void svc_tcp_listen_data_ready(struct sock *sk, int count_unused)
644 {
645         struct svc_sock *svsk = (struct svc_sock *)sk->sk_user_data;
646
647         dprintk("svc: socket %p TCP (listen) state change %d\n",
648                 sk, sk->sk_state);
649
650         /*
651          * This callback may called twice when a new connection
652          * is established as a child socket inherits everything
653          * from a parent LISTEN socket.
654          * 1) data_ready method of the parent socket will be called
655          *    when one of child sockets become ESTABLISHED.
656          * 2) data_ready method of the child socket may be called
657          *    when it receives data before the socket is accepted.
658          * In case of 2, we should ignore it silently.
659          */
660         if (sk->sk_state == TCP_LISTEN) {
661                 if (svsk) {
662                         set_bit(XPT_CONN, &svsk->sk_xprt.xpt_flags);
663                         svc_xprt_enqueue(&svsk->sk_xprt);
664                 } else
665                         printk("svc: socket %p: no user data\n", sk);
666         }
667
668         if (sk->sk_sleep && waitqueue_active(sk->sk_sleep))
669                 wake_up_interruptible_all(sk->sk_sleep);
670 }
671
672 /*
673  * A state change on a connected socket means it's dying or dead.
674  */
675 static void svc_tcp_state_change(struct sock *sk)
676 {
677         struct svc_sock *svsk = (struct svc_sock *)sk->sk_user_data;
678
679         dprintk("svc: socket %p TCP (connected) state change %d (svsk %p)\n",
680                 sk, sk->sk_state, sk->sk_user_data);
681
682         if (!svsk)
683                 printk("svc: socket %p: no user data\n", sk);
684         else {
685                 set_bit(XPT_CLOSE, &svsk->sk_xprt.xpt_flags);
686                 svc_xprt_enqueue(&svsk->sk_xprt);
687         }
688         if (sk->sk_sleep && waitqueue_active(sk->sk_sleep))
689                 wake_up_interruptible_all(sk->sk_sleep);
690 }
691
692 static void svc_tcp_data_ready(struct sock *sk, int count)
693 {
694         struct svc_sock *svsk = (struct svc_sock *)sk->sk_user_data;
695
696         dprintk("svc: socket %p TCP data ready (svsk %p)\n",
697                 sk, sk->sk_user_data);
698         if (svsk) {
699                 set_bit(XPT_DATA, &svsk->sk_xprt.xpt_flags);
700                 svc_xprt_enqueue(&svsk->sk_xprt);
701         }
702         if (sk->sk_sleep && waitqueue_active(sk->sk_sleep))
703                 wake_up_interruptible(sk->sk_sleep);
704 }
705
706 /*
707  * Accept a TCP connection
708  */
709 static struct svc_xprt *svc_tcp_accept(struct svc_xprt *xprt)
710 {
711         struct svc_sock *svsk = container_of(xprt, struct svc_sock, sk_xprt);
712         struct sockaddr_storage addr;
713         struct sockaddr *sin = (struct sockaddr *) &addr;
714         struct svc_serv *serv = svsk->sk_xprt.xpt_server;
715         struct socket   *sock = svsk->sk_sock;
716         struct socket   *newsock;
717         struct svc_sock *newsvsk;
718         int             err, slen;
719         RPC_IFDEBUG(char buf[RPC_MAX_ADDRBUFLEN]);
720
721         dprintk("svc: tcp_accept %p sock %p\n", svsk, sock);
722         if (!sock)
723                 return NULL;
724
725         clear_bit(XPT_CONN, &svsk->sk_xprt.xpt_flags);
726         err = kernel_accept(sock, &newsock, O_NONBLOCK);
727         if (err < 0) {
728                 if (err == -ENOMEM)
729                         printk(KERN_WARNING "%s: no more sockets!\n",
730                                serv->sv_name);
731                 else if (err != -EAGAIN && net_ratelimit())
732                         printk(KERN_WARNING "%s: accept failed (err %d)!\n",
733                                    serv->sv_name, -err);
734                 return NULL;
735         }
736         set_bit(XPT_CONN, &svsk->sk_xprt.xpt_flags);
737
738         err = kernel_getpeername(newsock, sin, &slen);
739         if (err < 0) {
740                 if (net_ratelimit())
741                         printk(KERN_WARNING "%s: peername failed (err %d)!\n",
742                                    serv->sv_name, -err);
743                 goto failed;            /* aborted connection or whatever */
744         }
745
746         /* Ideally, we would want to reject connections from unauthorized
747          * hosts here, but when we get encryption, the IP of the host won't
748          * tell us anything.  For now just warn about unpriv connections.
749          */
750         if (!svc_port_is_privileged(sin)) {
751                 dprintk(KERN_WARNING
752                         "%s: connect from unprivileged port: %s\n",
753                         serv->sv_name,
754                         __svc_print_addr(sin, buf, sizeof(buf)));
755         }
756         dprintk("%s: connect from %s\n", serv->sv_name,
757                 __svc_print_addr(sin, buf, sizeof(buf)));
758
759         /* make sure that a write doesn't block forever when
760          * low on memory
761          */
762         newsock->sk->sk_sndtimeo = HZ*30;
763
764         if (!(newsvsk = svc_setup_socket(serv, newsock, &err,
765                                  (SVC_SOCK_ANONYMOUS | SVC_SOCK_TEMPORARY))))
766                 goto failed;
767         svc_xprt_set_remote(&newsvsk->sk_xprt, sin, slen);
768         err = kernel_getsockname(newsock, sin, &slen);
769         if (unlikely(err < 0)) {
770                 dprintk("svc_tcp_accept: kernel_getsockname error %d\n", -err);
771                 slen = offsetof(struct sockaddr, sa_data);
772         }
773         svc_xprt_set_local(&newsvsk->sk_xprt, sin, slen);
774
775         if (serv->sv_stats)
776                 serv->sv_stats->nettcpconn++;
777
778         return &newsvsk->sk_xprt;
779
780 failed:
781         sock_release(newsock);
782         return NULL;
783 }
784
785 /*
786  * Receive data from a TCP socket.
787  */
788 static int svc_tcp_recvfrom(struct svc_rqst *rqstp)
789 {
790         struct svc_sock *svsk =
791                 container_of(rqstp->rq_xprt, struct svc_sock, sk_xprt);
792         struct svc_serv *serv = svsk->sk_xprt.xpt_server;
793         int             len;
794         struct kvec *vec;
795         int pnum, vlen;
796
797         dprintk("svc: tcp_recv %p data %d conn %d close %d\n",
798                 svsk, test_bit(XPT_DATA, &svsk->sk_xprt.xpt_flags),
799                 test_bit(XPT_CONN, &svsk->sk_xprt.xpt_flags),
800                 test_bit(XPT_CLOSE, &svsk->sk_xprt.xpt_flags));
801
802         if (test_and_clear_bit(XPT_CHNGBUF, &svsk->sk_xprt.xpt_flags))
803                 /* sndbuf needs to have room for one request
804                  * per thread, otherwise we can stall even when the
805                  * network isn't a bottleneck.
806                  *
807                  * We count all threads rather than threads in a
808                  * particular pool, which provides an upper bound
809                  * on the number of threads which will access the socket.
810                  *
811                  * rcvbuf just needs to be able to hold a few requests.
812                  * Normally they will be removed from the queue
813                  * as soon a a complete request arrives.
814                  */
815                 svc_sock_setbufsize(svsk->sk_sock,
816                                     (serv->sv_nrthreads+3) * serv->sv_max_mesg,
817                                     3 * serv->sv_max_mesg);
818
819         clear_bit(XPT_DATA, &svsk->sk_xprt.xpt_flags);
820
821         /* Receive data. If we haven't got the record length yet, get
822          * the next four bytes. Otherwise try to gobble up as much as
823          * possible up to the complete record length.
824          */
825         if (svsk->sk_tcplen < 4) {
826                 unsigned long   want = 4 - svsk->sk_tcplen;
827                 struct kvec     iov;
828
829                 iov.iov_base = ((char *) &svsk->sk_reclen) + svsk->sk_tcplen;
830                 iov.iov_len  = want;
831                 if ((len = svc_recvfrom(rqstp, &iov, 1, want)) < 0)
832                         goto error;
833                 svsk->sk_tcplen += len;
834
835                 if (len < want) {
836                         dprintk("svc: short recvfrom while reading record length (%d of %lu)\n",
837                                 len, want);
838                         svc_xprt_received(&svsk->sk_xprt);
839                         return -EAGAIN; /* record header not complete */
840                 }
841
842                 svsk->sk_reclen = ntohl(svsk->sk_reclen);
843                 if (!(svsk->sk_reclen & 0x80000000)) {
844                         /* FIXME: technically, a record can be fragmented,
845                          *  and non-terminal fragments will not have the top
846                          *  bit set in the fragment length header.
847                          *  But apparently no known nfs clients send fragmented
848                          *  records. */
849                         if (net_ratelimit())
850                                 printk(KERN_NOTICE "RPC: bad TCP reclen 0x%08lx"
851                                        " (non-terminal)\n",
852                                        (unsigned long) svsk->sk_reclen);
853                         goto err_delete;
854                 }
855                 svsk->sk_reclen &= 0x7fffffff;
856                 dprintk("svc: TCP record, %d bytes\n", svsk->sk_reclen);
857                 if (svsk->sk_reclen > serv->sv_max_mesg) {
858                         if (net_ratelimit())
859                                 printk(KERN_NOTICE "RPC: bad TCP reclen 0x%08lx"
860                                        " (large)\n",
861                                        (unsigned long) svsk->sk_reclen);
862                         goto err_delete;
863                 }
864         }
865
866         /* Check whether enough data is available */
867         len = svc_recv_available(svsk);
868         if (len < 0)
869                 goto error;
870
871         if (len < svsk->sk_reclen) {
872                 dprintk("svc: incomplete TCP record (%d of %d)\n",
873                         len, svsk->sk_reclen);
874                 svc_xprt_received(&svsk->sk_xprt);
875                 return -EAGAIN; /* record not complete */
876         }
877         len = svsk->sk_reclen;
878         set_bit(XPT_DATA, &svsk->sk_xprt.xpt_flags);
879
880         vec = rqstp->rq_vec;
881         vec[0] = rqstp->rq_arg.head[0];
882         vlen = PAGE_SIZE;
883         pnum = 1;
884         while (vlen < len) {
885                 vec[pnum].iov_base = page_address(rqstp->rq_pages[pnum]);
886                 vec[pnum].iov_len = PAGE_SIZE;
887                 pnum++;
888                 vlen += PAGE_SIZE;
889         }
890         rqstp->rq_respages = &rqstp->rq_pages[pnum];
891
892         /* Now receive data */
893         len = svc_recvfrom(rqstp, vec, pnum, len);
894         if (len < 0)
895                 goto error;
896
897         dprintk("svc: TCP complete record (%d bytes)\n", len);
898         rqstp->rq_arg.len = len;
899         rqstp->rq_arg.page_base = 0;
900         if (len <= rqstp->rq_arg.head[0].iov_len) {
901                 rqstp->rq_arg.head[0].iov_len = len;
902                 rqstp->rq_arg.page_len = 0;
903         } else {
904                 rqstp->rq_arg.page_len = len - rqstp->rq_arg.head[0].iov_len;
905         }
906
907         rqstp->rq_xprt_ctxt   = NULL;
908         rqstp->rq_prot        = IPPROTO_TCP;
909
910         /* Reset TCP read info */
911         svsk->sk_reclen = 0;
912         svsk->sk_tcplen = 0;
913
914         svc_xprt_copy_addrs(rqstp, &svsk->sk_xprt);
915         svc_xprt_received(&svsk->sk_xprt);
916         if (serv->sv_stats)
917                 serv->sv_stats->nettcpcnt++;
918
919         return len;
920
921  err_delete:
922         set_bit(XPT_CLOSE, &svsk->sk_xprt.xpt_flags);
923         return -EAGAIN;
924
925  error:
926         if (len == -EAGAIN) {
927                 dprintk("RPC: TCP recvfrom got EAGAIN\n");
928                 svc_xprt_received(&svsk->sk_xprt);
929         } else {
930                 printk(KERN_NOTICE "%s: recvfrom returned errno %d\n",
931                        svsk->sk_xprt.xpt_server->sv_name, -len);
932                 goto err_delete;
933         }
934
935         return len;
936 }
937
938 /*
939  * Send out data on TCP socket.
940  */
941 static int svc_tcp_sendto(struct svc_rqst *rqstp)
942 {
943         struct xdr_buf  *xbufp = &rqstp->rq_res;
944         int sent;
945         __be32 reclen;
946
947         /* Set up the first element of the reply kvec.
948          * Any other kvecs that may be in use have been taken
949          * care of by the server implementation itself.
950          */
951         reclen = htonl(0x80000000|((xbufp->len ) - 4));
952         memcpy(xbufp->head[0].iov_base, &reclen, 4);
953
954         if (test_bit(XPT_DEAD, &rqstp->rq_xprt->xpt_flags))
955                 return -ENOTCONN;
956
957         sent = svc_sendto(rqstp, &rqstp->rq_res);
958         if (sent != xbufp->len) {
959                 printk(KERN_NOTICE
960                        "rpc-srv/tcp: %s: %s %d when sending %d bytes "
961                        "- shutting down socket\n",
962                        rqstp->rq_xprt->xpt_server->sv_name,
963                        (sent<0)?"got error":"sent only",
964                        sent, xbufp->len);
965                 set_bit(XPT_CLOSE, &rqstp->rq_xprt->xpt_flags);
966                 svc_xprt_enqueue(rqstp->rq_xprt);
967                 sent = -EAGAIN;
968         }
969         return sent;
970 }
971
972 /*
973  * Setup response header. TCP has a 4B record length field.
974  */
975 static void svc_tcp_prep_reply_hdr(struct svc_rqst *rqstp)
976 {
977         struct kvec *resv = &rqstp->rq_res.head[0];
978
979         /* tcp needs a space for the record length... */
980         svc_putnl(resv, 0);
981 }
982
983 static int svc_tcp_has_wspace(struct svc_xprt *xprt)
984 {
985         struct svc_sock *svsk = container_of(xprt, struct svc_sock, sk_xprt);
986         struct svc_serv *serv = svsk->sk_xprt.xpt_server;
987         int required;
988         int wspace;
989
990         /*
991          * Set the SOCK_NOSPACE flag before checking the available
992          * sock space.
993          */
994         set_bit(SOCK_NOSPACE, &svsk->sk_sock->flags);
995         required = atomic_read(&svsk->sk_xprt.xpt_reserved) + serv->sv_max_mesg;
996         wspace = sk_stream_wspace(svsk->sk_sk);
997
998         if (wspace < sk_stream_min_wspace(svsk->sk_sk))
999                 return 0;
1000         if (required * 2 > wspace)
1001                 return 0;
1002
1003         clear_bit(SOCK_NOSPACE, &svsk->sk_sock->flags);
1004         return 1;
1005 }
1006
1007 static struct svc_xprt *svc_tcp_create(struct svc_serv *serv,
1008                                        struct sockaddr *sa, int salen,
1009                                        int flags)
1010 {
1011         return svc_create_socket(serv, IPPROTO_TCP, sa, salen, flags);
1012 }
1013
1014 static struct svc_xprt_ops svc_tcp_ops = {
1015         .xpo_create = svc_tcp_create,
1016         .xpo_recvfrom = svc_tcp_recvfrom,
1017         .xpo_sendto = svc_tcp_sendto,
1018         .xpo_release_rqst = svc_release_skb,
1019         .xpo_detach = svc_sock_detach,
1020         .xpo_free = svc_sock_free,
1021         .xpo_prep_reply_hdr = svc_tcp_prep_reply_hdr,
1022         .xpo_has_wspace = svc_tcp_has_wspace,
1023         .xpo_accept = svc_tcp_accept,
1024 };
1025
1026 static struct svc_xprt_class svc_tcp_class = {
1027         .xcl_name = "tcp",
1028         .xcl_owner = THIS_MODULE,
1029         .xcl_ops = &svc_tcp_ops,
1030         .xcl_max_payload = RPCSVC_MAXPAYLOAD_TCP,
1031 };
1032
1033 void svc_init_xprt_sock(void)
1034 {
1035         svc_reg_xprt_class(&svc_tcp_class);
1036         svc_reg_xprt_class(&svc_udp_class);
1037 }
1038
1039 void svc_cleanup_xprt_sock(void)
1040 {
1041         svc_unreg_xprt_class(&svc_tcp_class);
1042         svc_unreg_xprt_class(&svc_udp_class);
1043 }
1044
1045 static void svc_tcp_init(struct svc_sock *svsk, struct svc_serv *serv)
1046 {
1047         struct sock     *sk = svsk->sk_sk;
1048         struct tcp_sock *tp = tcp_sk(sk);
1049
1050         svc_xprt_init(&svc_tcp_class, &svsk->sk_xprt, serv);
1051         set_bit(XPT_CACHE_AUTH, &svsk->sk_xprt.xpt_flags);
1052         if (sk->sk_state == TCP_LISTEN) {
1053                 dprintk("setting up TCP socket for listening\n");
1054                 set_bit(XPT_LISTENER, &svsk->sk_xprt.xpt_flags);
1055                 sk->sk_data_ready = svc_tcp_listen_data_ready;
1056                 set_bit(XPT_CONN, &svsk->sk_xprt.xpt_flags);
1057         } else {
1058                 dprintk("setting up TCP socket for reading\n");
1059                 sk->sk_state_change = svc_tcp_state_change;
1060                 sk->sk_data_ready = svc_tcp_data_ready;
1061                 sk->sk_write_space = svc_write_space;
1062
1063                 svsk->sk_reclen = 0;
1064                 svsk->sk_tcplen = 0;
1065
1066                 tp->nonagle = 1;        /* disable Nagle's algorithm */
1067
1068                 /* initialise setting must have enough space to
1069                  * receive and respond to one request.
1070                  * svc_tcp_recvfrom will re-adjust if necessary
1071                  */
1072                 svc_sock_setbufsize(svsk->sk_sock,
1073                                     3 * svsk->sk_xprt.xpt_server->sv_max_mesg,
1074                                     3 * svsk->sk_xprt.xpt_server->sv_max_mesg);
1075
1076                 set_bit(XPT_CHNGBUF, &svsk->sk_xprt.xpt_flags);
1077                 set_bit(XPT_DATA, &svsk->sk_xprt.xpt_flags);
1078                 if (sk->sk_state != TCP_ESTABLISHED)
1079                         set_bit(XPT_CLOSE, &svsk->sk_xprt.xpt_flags);
1080         }
1081 }
1082
1083 void svc_sock_update_bufs(struct svc_serv *serv)
1084 {
1085         /*
1086          * The number of server threads has changed. Update
1087          * rcvbuf and sndbuf accordingly on all sockets
1088          */
1089         struct list_head *le;
1090
1091         spin_lock_bh(&serv->sv_lock);
1092         list_for_each(le, &serv->sv_permsocks) {
1093                 struct svc_sock *svsk =
1094                         list_entry(le, struct svc_sock, sk_xprt.xpt_list);
1095                 set_bit(XPT_CHNGBUF, &svsk->sk_xprt.xpt_flags);
1096         }
1097         list_for_each(le, &serv->sv_tempsocks) {
1098                 struct svc_sock *svsk =
1099                         list_entry(le, struct svc_sock, sk_xprt.xpt_list);
1100                 set_bit(XPT_CHNGBUF, &svsk->sk_xprt.xpt_flags);
1101         }
1102         spin_unlock_bh(&serv->sv_lock);
1103 }
1104
1105 /*
1106  * Initialize socket for RPC use and create svc_sock struct
1107  * XXX: May want to setsockopt SO_SNDBUF and SO_RCVBUF.
1108  */
1109 static struct svc_sock *svc_setup_socket(struct svc_serv *serv,
1110                                                 struct socket *sock,
1111                                                 int *errp, int flags)
1112 {
1113         struct svc_sock *svsk;
1114         struct sock     *inet;
1115         int             pmap_register = !(flags & SVC_SOCK_ANONYMOUS);
1116
1117         dprintk("svc: svc_setup_socket %p\n", sock);
1118         if (!(svsk = kzalloc(sizeof(*svsk), GFP_KERNEL))) {
1119                 *errp = -ENOMEM;
1120                 return NULL;
1121         }
1122
1123         inet = sock->sk;
1124
1125         /* Register socket with portmapper */
1126         if (*errp >= 0 && pmap_register)
1127                 *errp = svc_register(serv, inet->sk_protocol,
1128                                      ntohs(inet_sk(inet)->sport));
1129
1130         if (*errp < 0) {
1131                 kfree(svsk);
1132                 return NULL;
1133         }
1134
1135         inet->sk_user_data = svsk;
1136         svsk->sk_sock = sock;
1137         svsk->sk_sk = inet;
1138         svsk->sk_ostate = inet->sk_state_change;
1139         svsk->sk_odata = inet->sk_data_ready;
1140         svsk->sk_owspace = inet->sk_write_space;
1141
1142         /* Initialize the socket */
1143         if (sock->type == SOCK_DGRAM)
1144                 svc_udp_init(svsk, serv);
1145         else
1146                 svc_tcp_init(svsk, serv);
1147
1148         dprintk("svc: svc_setup_socket created %p (inet %p)\n",
1149                                 svsk, svsk->sk_sk);
1150
1151         return svsk;
1152 }
1153
1154 int svc_addsock(struct svc_serv *serv,
1155                 int fd,
1156                 char *name_return,
1157                 int *proto)
1158 {
1159         int err = 0;
1160         struct socket *so = sockfd_lookup(fd, &err);
1161         struct svc_sock *svsk = NULL;
1162
1163         if (!so)
1164                 return err;
1165         if (so->sk->sk_family != AF_INET)
1166                 err =  -EAFNOSUPPORT;
1167         else if (so->sk->sk_protocol != IPPROTO_TCP &&
1168             so->sk->sk_protocol != IPPROTO_UDP)
1169                 err =  -EPROTONOSUPPORT;
1170         else if (so->state > SS_UNCONNECTED)
1171                 err = -EISCONN;
1172         else {
1173                 svsk = svc_setup_socket(serv, so, &err, SVC_SOCK_DEFAULTS);
1174                 if (svsk) {
1175                         struct sockaddr_storage addr;
1176                         struct sockaddr *sin = (struct sockaddr *)&addr;
1177                         int salen;
1178                         if (kernel_getsockname(svsk->sk_sock, sin, &salen) == 0)
1179                                 svc_xprt_set_local(&svsk->sk_xprt, sin, salen);
1180                         clear_bit(XPT_TEMP, &svsk->sk_xprt.xpt_flags);
1181                         spin_lock_bh(&serv->sv_lock);
1182                         list_add(&svsk->sk_xprt.xpt_list, &serv->sv_permsocks);
1183                         spin_unlock_bh(&serv->sv_lock);
1184                         svc_xprt_received(&svsk->sk_xprt);
1185                         err = 0;
1186                 }
1187         }
1188         if (err) {
1189                 sockfd_put(so);
1190                 return err;
1191         }
1192         if (proto) *proto = so->sk->sk_protocol;
1193         return one_sock_name(name_return, svsk);
1194 }
1195 EXPORT_SYMBOL_GPL(svc_addsock);
1196
1197 /*
1198  * Create socket for RPC service.
1199  */
1200 static struct svc_xprt *svc_create_socket(struct svc_serv *serv,
1201                                           int protocol,
1202                                           struct sockaddr *sin, int len,
1203                                           int flags)
1204 {
1205         struct svc_sock *svsk;
1206         struct socket   *sock;
1207         int             error;
1208         int             type;
1209         struct sockaddr_storage addr;
1210         struct sockaddr *newsin = (struct sockaddr *)&addr;
1211         int             newlen;
1212         RPC_IFDEBUG(char buf[RPC_MAX_ADDRBUFLEN]);
1213
1214         dprintk("svc: svc_create_socket(%s, %d, %s)\n",
1215                         serv->sv_program->pg_name, protocol,
1216                         __svc_print_addr(sin, buf, sizeof(buf)));
1217
1218         if (protocol != IPPROTO_UDP && protocol != IPPROTO_TCP) {
1219                 printk(KERN_WARNING "svc: only UDP and TCP "
1220                                 "sockets supported\n");
1221                 return ERR_PTR(-EINVAL);
1222         }
1223         type = (protocol == IPPROTO_UDP)? SOCK_DGRAM : SOCK_STREAM;
1224
1225         error = sock_create_kern(sin->sa_family, type, protocol, &sock);
1226         if (error < 0)
1227                 return ERR_PTR(error);
1228
1229         svc_reclassify_socket(sock);
1230
1231         if (type == SOCK_STREAM)
1232                 sock->sk->sk_reuse = 1;         /* allow address reuse */
1233         error = kernel_bind(sock, sin, len);
1234         if (error < 0)
1235                 goto bummer;
1236
1237         newlen = len;
1238         error = kernel_getsockname(sock, newsin, &newlen);
1239         if (error < 0)
1240                 goto bummer;
1241
1242         if (protocol == IPPROTO_TCP) {
1243                 if ((error = kernel_listen(sock, 64)) < 0)
1244                         goto bummer;
1245         }
1246
1247         if ((svsk = svc_setup_socket(serv, sock, &error, flags)) != NULL) {
1248                 svc_xprt_set_local(&svsk->sk_xprt, newsin, newlen);
1249                 return (struct svc_xprt *)svsk;
1250         }
1251
1252 bummer:
1253         dprintk("svc: svc_create_socket error = %d\n", -error);
1254         sock_release(sock);
1255         return ERR_PTR(error);
1256 }
1257
1258 /*
1259  * Detach the svc_sock from the socket so that no
1260  * more callbacks occur.
1261  */
1262 static void svc_sock_detach(struct svc_xprt *xprt)
1263 {
1264         struct svc_sock *svsk = container_of(xprt, struct svc_sock, sk_xprt);
1265         struct sock *sk = svsk->sk_sk;
1266
1267         dprintk("svc: svc_sock_detach(%p)\n", svsk);
1268
1269         /* put back the old socket callbacks */
1270         sk->sk_state_change = svsk->sk_ostate;
1271         sk->sk_data_ready = svsk->sk_odata;
1272         sk->sk_write_space = svsk->sk_owspace;
1273 }
1274
1275 /*
1276  * Free the svc_sock's socket resources and the svc_sock itself.
1277  */
1278 static void svc_sock_free(struct svc_xprt *xprt)
1279 {
1280         struct svc_sock *svsk = container_of(xprt, struct svc_sock, sk_xprt);
1281         dprintk("svc: svc_sock_free(%p)\n", svsk);
1282
1283         if (svsk->sk_sock->file)
1284                 sockfd_put(svsk->sk_sock);
1285         else
1286                 sock_release(svsk->sk_sock);
1287         kfree(svsk);
1288 }