]> git.proxmox.com Git - mirror_ubuntu-jammy-kernel.git/blob - net/core/sock.c
projects / mirror_ubuntu-jammy-kernel.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
Merge master.kernel.org:/pub/scm/linux/kernel/git/gregkh/pci-2.6
[mirror_ubuntu-jammy-kernel.git] / net / core / sock.c
1 /*
2 * INET An implementation of the TCP/IP protocol suite for the LINUX
3 * operating system. INET is implemented using the BSD Socket
4 * interface as the means of communication with the user level.
5 *
6 * Generic socket support routines. Memory allocators, socket lock/release
7 * handler for protocols to use and generic option handler.
8 *
9 *
10 * Version: $Id: sock.c,v 1.117 2002/02/01 22:01:03 davem Exp $
11 *
12 * Authors: Ross Biro
13 * Fred N. van Kempen, <waltje@uWalt.NL.Mugnet.ORG>
14 * Florian La Roche, <flla@stud.uni-sb.de>
15 * Alan Cox, <A.Cox@swansea.ac.uk>
16 *
17 * Fixes:
18 * Alan Cox : Numerous verify_area() problems
19 * Alan Cox : Connecting on a connecting socket
20 * now returns an error for tcp.
21 * Alan Cox : sock->protocol is set correctly.
22 * and is not sometimes left as 0.
23 * Alan Cox : connect handles icmp errors on a
24 * connect properly. Unfortunately there
25 * is a restart syscall nasty there. I
26 * can't match BSD without hacking the C
27 * library. Ideas urgently sought!
28 * Alan Cox : Disallow bind() to addresses that are
29 * not ours - especially broadcast ones!!
30 * Alan Cox : Socket 1024 _IS_ ok for users. (fencepost)
31 * Alan Cox : sock_wfree/sock_rfree don't destroy sockets,
32 * instead they leave that for the DESTROY timer.
33 * Alan Cox : Clean up error flag in accept
34 * Alan Cox : TCP ack handling is buggy, the DESTROY timer
35 * was buggy. Put a remove_sock() in the handler
36 * for memory when we hit 0. Also altered the timer
37 * code. The ACK stuff can wait and needs major
38 * TCP layer surgery.
39 * Alan Cox : Fixed TCP ack bug, removed remove sock
40 * and fixed timer/inet_bh race.
41 * Alan Cox : Added zapped flag for TCP
42 * Alan Cox : Move kfree_skb into skbuff.c and tidied up surplus code
43 * Alan Cox : for new sk_buff allocations wmalloc/rmalloc now call alloc_skb
44 * Alan Cox : kfree_s calls now are kfree_skbmem so we can track skb resources
45 * Alan Cox : Supports socket option broadcast now as does udp. Packet and raw need fixing.
46 * Alan Cox : Added RCVBUF,SNDBUF size setting. It suddenly occurred to me how easy it was so...
47 * Rick Sladkey : Relaxed UDP rules for matching packets.
48 * C.E.Hawkins : IFF_PROMISC/SIOCGHWADDR support
49 * Pauline Middelink : identd support
50 * Alan Cox : Fixed connect() taking signals I think.
51 * Alan Cox : SO_LINGER supported
52 * Alan Cox : Error reporting fixes
53 * Anonymous : inet_create tidied up (sk->reuse setting)
54 * Alan Cox : inet sockets don't set sk->type!
55 * Alan Cox : Split socket option code
56 * Alan Cox : Callbacks
57 * Alan Cox : Nagle flag for Charles & Johannes stuff
58 * Alex : Removed restriction on inet fioctl
59 * Alan Cox : Splitting INET from NET core
60 * Alan Cox : Fixed bogus SO_TYPE handling in getsockopt()
61 * Adam Caldwell : Missing return in SO_DONTROUTE/SO_DEBUG code
62 * Alan Cox : Split IP from generic code
63 * Alan Cox : New kfree_skbmem()
64 * Alan Cox : Make SO_DEBUG superuser only.
65 * Alan Cox : Allow anyone to clear SO_DEBUG
66 * (compatibility fix)
67 * Alan Cox : Added optimistic memory grabbing for AF_UNIX throughput.
68 * Alan Cox : Allocator for a socket is settable.
69 * Alan Cox : SO_ERROR includes soft errors.
70 * Alan Cox : Allow NULL arguments on some SO_ opts
71 * Alan Cox : Generic socket allocation to make hooks
72 * easier (suggested by Craig Metz).
73 * Michael Pall : SO_ERROR returns positive errno again
74 * Steve Whitehouse: Added default destructor to free
75 * protocol private data.
76 * Steve Whitehouse: Added various other default routines
77 * common to several socket families.
78 * Chris Evans : Call suser() check last on F_SETOWN
79 * Jay Schulist : Added SO_ATTACH_FILTER and SO_DETACH_FILTER.
80 * Andi Kleen : Add sock_kmalloc()/sock_kfree_s()
81 * Andi Kleen : Fix write_space callback
82 * Chris Evans : Security fixes - signedness again
83 * Arnaldo C. Melo : cleanups, use skb_queue_purge
84 *
85 * To Fix:
86 *
87 *
88 * This program is free software; you can redistribute it and/or
89 * modify it under the terms of the GNU General Public License
90 * as published by the Free Software Foundation; either version
91 * 2 of the License, or (at your option) any later version.
92 */
93
94 #include <linux/capability.h>
95 #include <linux/config.h>
96 #include <linux/errno.h>
97 #include <linux/types.h>
98 #include <linux/socket.h>
99 #include <linux/in.h>
100 #include <linux/kernel.h>
101 #include <linux/module.h>
102 #include <linux/proc_fs.h>
103 #include <linux/seq_file.h>
104 #include <linux/sched.h>
105 #include <linux/timer.h>
106 #include <linux/string.h>
107 #include <linux/sockios.h>
108 #include <linux/net.h>
109 #include <linux/mm.h>
110 #include <linux/slab.h>
111 #include <linux/interrupt.h>
112 #include <linux/poll.h>
113 #include <linux/tcp.h>
114 #include <linux/init.h>
115
116 #include <asm/uaccess.h>
117 #include <asm/system.h>
118
119 #include <linux/netdevice.h>
120 #include <net/protocol.h>
121 #include <linux/skbuff.h>
122 #include <net/request_sock.h>
123 #include <net/sock.h>
124 #include <net/xfrm.h>
125 #include <linux/ipsec.h>
126
127 #include <linux/filter.h>
128
129 #ifdef CONFIG_INET
130 #include <net/tcp.h>
131 #endif
132
133 /* Take into consideration the size of the struct sk_buff overhead in the
134 * determination of these values, since that is non-constant across
135 * platforms. This makes socket queueing behavior and performance
136 * not depend upon such differences.
137 */
138 #define _SK_MEM_PACKETS 256
139 #define _SK_MEM_OVERHEAD (sizeof(struct sk_buff) + 256)
140 #define SK_WMEM_MAX (_SK_MEM_OVERHEAD * _SK_MEM_PACKETS)
141 #define SK_RMEM_MAX (_SK_MEM_OVERHEAD * _SK_MEM_PACKETS)
142
143 /* Run time adjustable parameters. */
144 __u32 sysctl_wmem_max = SK_WMEM_MAX;
145 __u32 sysctl_rmem_max = SK_RMEM_MAX;
146 __u32 sysctl_wmem_default = SK_WMEM_MAX;
147 __u32 sysctl_rmem_default = SK_RMEM_MAX;
148
149 /* Maximal space eaten by iovec or ancilliary data plus some space */
150 int sysctl_optmem_max = sizeof(unsigned long)*(2*UIO_MAXIOV + 512);
151
152 static int sock_set_timeout(long *timeo_p, char __user *optval, int optlen)
153 {
154 struct timeval tv;
155
156 if (optlen < sizeof(tv))
157 return -EINVAL;
158 if (copy_from_user(&tv, optval, sizeof(tv)))
159 return -EFAULT;
160
161 *timeo_p = MAX_SCHEDULE_TIMEOUT;
162 if (tv.tv_sec == 0 && tv.tv_usec == 0)
163 return 0;
164 if (tv.tv_sec < (MAX_SCHEDULE_TIMEOUT/HZ - 1))
165 *timeo_p = tv.tv_sec*HZ + (tv.tv_usec+(1000000/HZ-1))/(1000000/HZ);
166 return 0;
167 }
168
169 static void sock_warn_obsolete_bsdism(const char *name)
170 {
171 static int warned;
172 static char warncomm[TASK_COMM_LEN];
173 if (strcmp(warncomm, current->comm) && warned < 5) {
174 strcpy(warncomm, current->comm);
175 printk(KERN_WARNING "process `%s' is using obsolete "
176 "%s SO_BSDCOMPAT\n", warncomm, name);
177 warned++;
178 }
179 }
180
181 static void sock_disable_timestamp(struct sock *sk)
182 {
183 if (sock_flag(sk, SOCK_TIMESTAMP)) {
184 sock_reset_flag(sk, SOCK_TIMESTAMP);
185 net_disable_timestamp();
186 }
187 }
188
189
190 int sock_queue_rcv_skb(struct sock *sk, struct sk_buff *skb)
191 {
192 int err = 0;
193 int skb_len;
194
195 /* Cast skb->rcvbuf to unsigned... It's pointless, but reduces
196 number of warnings when compiling with -W --ANK
197 */
198 if (atomic_read(&sk->sk_rmem_alloc) + skb->truesize >=
199 (unsigned)sk->sk_rcvbuf) {
200 err = -ENOMEM;
201 goto out;
202 }
203
204 /* It would be deadlock, if sock_queue_rcv_skb is used
205 with socket lock! We assume that users of this
206 function are lock free.
207 */
208 err = sk_filter(sk, skb, 1);
209 if (err)
210 goto out;
211
212 skb->dev = NULL;
213 skb_set_owner_r(skb, sk);
214
215 /* Cache the SKB length before we tack it onto the receive
216 * queue. Once it is added it no longer belongs to us and
217 * may be freed by other threads of control pulling packets
218 * from the queue.
219 */
220 skb_len = skb->len;
221
222 skb_queue_tail(&sk->sk_receive_queue, skb);
223
224 if (!sock_flag(sk, SOCK_DEAD))
225 sk->sk_data_ready(sk, skb_len);
226 out:
227 return err;
228 }
229 EXPORT_SYMBOL(sock_queue_rcv_skb);
230
231 int sk_receive_skb(struct sock *sk, struct sk_buff *skb)
232 {
233 int rc = NET_RX_SUCCESS;
234
235 if (sk_filter(sk, skb, 0))
236 goto discard_and_relse;
237
238 skb->dev = NULL;
239
240 bh_lock_sock(sk);
241 if (!sock_owned_by_user(sk))
242 rc = sk->sk_backlog_rcv(sk, skb);
243 else
244 sk_add_backlog(sk, skb);
245 bh_unlock_sock(sk);
246 out:
247 sock_put(sk);
248 return rc;
249 discard_and_relse:
250 kfree_skb(skb);
251 goto out;
252 }
253 EXPORT_SYMBOL(sk_receive_skb);
254
255 struct dst_entry *__sk_dst_check(struct sock *sk, u32 cookie)
256 {
257 struct dst_entry *dst = sk->sk_dst_cache;
258
259 if (dst && dst->obsolete && dst->ops->check(dst, cookie) == NULL) {
260 sk->sk_dst_cache = NULL;
261 dst_release(dst);
262 return NULL;
263 }
264
265 return dst;
266 }
267 EXPORT_SYMBOL(__sk_dst_check);
268
269 struct dst_entry *sk_dst_check(struct sock *sk, u32 cookie)
270 {
271 struct dst_entry *dst = sk_dst_get(sk);
272
273 if (dst && dst->obsolete && dst->ops->check(dst, cookie) == NULL) {
274 sk_dst_reset(sk);
275 dst_release(dst);
276 return NULL;
277 }
278
279 return dst;
280 }
281 EXPORT_SYMBOL(sk_dst_check);
282
283 /*
284 * This is meant for all protocols to use and covers goings on
285 * at the socket level. Everything here is generic.
286 */
287
288 int sock_setsockopt(struct socket *sock, int level, int optname,
289 char __user *optval, int optlen)
290 {
291 struct sock *sk=sock->sk;
292 struct sk_filter *filter;
293 int val;
294 int valbool;
295 struct linger ling;
296 int ret = 0;
297
298 /*
299 * Options without arguments
300 */
301
302 #ifdef SO_DONTLINGER /* Compatibility item... */
303 if (optname == SO_DONTLINGER) {
304 lock_sock(sk);
305 sock_reset_flag(sk, SOCK_LINGER);
306 release_sock(sk);
307 return 0;
308 }
309 #endif
310
311 if(optlen<sizeof(int))
312 return(-EINVAL);
313
314 if (get_user(val, (int __user *)optval))
315 return -EFAULT;
316
317 valbool = val?1:0;
318
319 lock_sock(sk);
320
321 switch(optname)
322 {
323 case SO_DEBUG:
324 if(val && !capable(CAP_NET_ADMIN))
325 {
326 ret = -EACCES;
327 }
328 else if (valbool)
329 sock_set_flag(sk, SOCK_DBG);
330 else
331 sock_reset_flag(sk, SOCK_DBG);
332 break;
333 case SO_REUSEADDR:
334 sk->sk_reuse = valbool;
335 break;
336 case SO_TYPE:
337 case SO_ERROR:
338 ret = -ENOPROTOOPT;
339 break;
340 case SO_DONTROUTE:
341 if (valbool)
342 sock_set_flag(sk, SOCK_LOCALROUTE);
343 else
344 sock_reset_flag(sk, SOCK_LOCALROUTE);
345 break;
346 case SO_BROADCAST:
347 sock_valbool_flag(sk, SOCK_BROADCAST, valbool);
348 break;
349 case SO_SNDBUF:
350 /* Don't error on this BSD doesn't and if you think
351 about it this is right. Otherwise apps have to
352 play 'guess the biggest size' games. RCVBUF/SNDBUF
353 are treated in BSD as hints */
354
355 if (val > sysctl_wmem_max)
356 val = sysctl_wmem_max;
357 set_sndbuf:
358 sk->sk_userlocks |= SOCK_SNDBUF_LOCK;
359 if ((val * 2) < SOCK_MIN_SNDBUF)
360 sk->sk_sndbuf = SOCK_MIN_SNDBUF;
361 else
362 sk->sk_sndbuf = val * 2;
363
364 /*
365 * Wake up sending tasks if we
366 * upped the value.
367 */
368 sk->sk_write_space(sk);
369 break;
370
371 case SO_SNDBUFFORCE:
372 if (!capable(CAP_NET_ADMIN)) {
373 ret = -EPERM;
374 break;
375 }
376 goto set_sndbuf;
377
378 case SO_RCVBUF:
379 /* Don't error on this BSD doesn't and if you think
380 about it this is right. Otherwise apps have to
381 play 'guess the biggest size' games. RCVBUF/SNDBUF
382 are treated in BSD as hints */
383
384 if (val > sysctl_rmem_max)
385 val = sysctl_rmem_max;
386 set_rcvbuf:
387 sk->sk_userlocks |= SOCK_RCVBUF_LOCK;
388 /*
389 * We double it on the way in to account for
390 * "struct sk_buff" etc. overhead. Applications
391 * assume that the SO_RCVBUF setting they make will
392 * allow that much actual data to be received on that
393 * socket.
394 *
395 * Applications are unaware that "struct sk_buff" and
396 * other overheads allocate from the receive buffer
397 * during socket buffer allocation.
398 *
399 * And after considering the possible alternatives,
400 * returning the value we actually used in getsockopt
401 * is the most desirable behavior.
402 */
403 if ((val * 2) < SOCK_MIN_RCVBUF)
404 sk->sk_rcvbuf = SOCK_MIN_RCVBUF;
405 else
406 sk->sk_rcvbuf = val * 2;
407 break;
408
409 case SO_RCVBUFFORCE:
410 if (!capable(CAP_NET_ADMIN)) {
411 ret = -EPERM;
412 break;
413 }
414 goto set_rcvbuf;
415
416 case SO_KEEPALIVE:
417 #ifdef CONFIG_INET
418 if (sk->sk_protocol == IPPROTO_TCP)
419 tcp_set_keepalive(sk, valbool);
420 #endif
421 sock_valbool_flag(sk, SOCK_KEEPOPEN, valbool);
422 break;
423
424 case SO_OOBINLINE:
425 sock_valbool_flag(sk, SOCK_URGINLINE, valbool);
426 break;
427
428 case SO_NO_CHECK:
429 sk->sk_no_check = valbool;
430 break;
431
432 case SO_PRIORITY:
433 if ((val >= 0 && val <= 6) || capable(CAP_NET_ADMIN))
434 sk->sk_priority = val;
435 else
436 ret = -EPERM;
437 break;
438
439 case SO_LINGER:
440 if(optlen<sizeof(ling)) {
441 ret = -EINVAL; /* 1003.1g */
442 break;
443 }
444 if (copy_from_user(&ling,optval,sizeof(ling))) {
445 ret = -EFAULT;
446 break;
447 }
448 if (!ling.l_onoff)
449 sock_reset_flag(sk, SOCK_LINGER);
450 else {
451 #if (BITS_PER_LONG == 32)
452 if ((unsigned int)ling.l_linger >= MAX_SCHEDULE_TIMEOUT/HZ)
453 sk->sk_lingertime = MAX_SCHEDULE_TIMEOUT;
454 else
455 #endif
456 sk->sk_lingertime = (unsigned int)ling.l_linger * HZ;
457 sock_set_flag(sk, SOCK_LINGER);
458 }
459 break;
460
461 case SO_BSDCOMPAT:
462 sock_warn_obsolete_bsdism("setsockopt");
463 break;
464
465 case SO_PASSCRED:
466 if (valbool)
467 set_bit(SOCK_PASSCRED, &sock->flags);
468 else
469 clear_bit(SOCK_PASSCRED, &sock->flags);
470 break;
471
472 case SO_TIMESTAMP:
473 if (valbool) {
474 sock_set_flag(sk, SOCK_RCVTSTAMP);
475 sock_enable_timestamp(sk);
476 } else
477 sock_reset_flag(sk, SOCK_RCVTSTAMP);
478 break;
479
480 case SO_RCVLOWAT:
481 if (val < 0)
482 val = INT_MAX;
483 sk->sk_rcvlowat = val ? : 1;
484 break;
485
486 case SO_RCVTIMEO:
487 ret = sock_set_timeout(&sk->sk_rcvtimeo, optval, optlen);
488 break;
489
490 case SO_SNDTIMEO:
491 ret = sock_set_timeout(&sk->sk_sndtimeo, optval, optlen);
492 break;
493
494 #ifdef CONFIG_NETDEVICES
495 case SO_BINDTODEVICE:
496 {
497 char devname[IFNAMSIZ];
498
499 /* Sorry... */
500 if (!capable(CAP_NET_RAW)) {
501 ret = -EPERM;
502 break;
503 }
504
505 /* Bind this socket to a particular device like "eth0",
506 * as specified in the passed interface name. If the
507 * name is "" or the option length is zero the socket
508 * is not bound.
509 */
510
511 if (!valbool) {
512 sk->sk_bound_dev_if = 0;
513 } else {
514 if (optlen > IFNAMSIZ - 1)
515 optlen = IFNAMSIZ - 1;
516 memset(devname, 0, sizeof(devname));
517 if (copy_from_user(devname, optval, optlen)) {
518 ret = -EFAULT;
519 break;
520 }
521
522 /* Remove any cached route for this socket. */
523 sk_dst_reset(sk);
524
525 if (devname[0] == '\0') {
526 sk->sk_bound_dev_if = 0;
527 } else {
528 struct net_device *dev = dev_get_by_name(devname);
529 if (!dev) {
530 ret = -ENODEV;
531 break;
532 }
533 sk->sk_bound_dev_if = dev->ifindex;
534 dev_put(dev);
535 }
536 }
537 break;
538 }
539 #endif
540
541
542 case SO_ATTACH_FILTER:
543 ret = -EINVAL;
544 if (optlen == sizeof(struct sock_fprog)) {
545 struct sock_fprog fprog;
546
547 ret = -EFAULT;
548 if (copy_from_user(&fprog, optval, sizeof(fprog)))
549 break;
550
551 ret = sk_attach_filter(&fprog, sk);
552 }
553 break;
554
555 case SO_DETACH_FILTER:
556 spin_lock_bh(&sk->sk_lock.slock);
557 filter = sk->sk_filter;
558 if (filter) {
559 sk->sk_filter = NULL;
560 spin_unlock_bh(&sk->sk_lock.slock);
561 sk_filter_release(sk, filter);
562 break;
563 }
564 spin_unlock_bh(&sk->sk_lock.slock);
565 ret = -ENONET;
566 break;
567
568 /* We implement the SO_SNDLOWAT etc to
569 not be settable (1003.1g 5.3) */
570 default:
571 ret = -ENOPROTOOPT;
572 break;
573 }
574 release_sock(sk);
575 return ret;
576 }
577
578
579 int sock_getsockopt(struct socket *sock, int level, int optname,
580 char __user *optval, int __user *optlen)
581 {
582 struct sock *sk = sock->sk;
583
584 union
585 {
586 int val;
587 struct linger ling;
588 struct timeval tm;
589 } v;
590
591 unsigned int lv = sizeof(int);
592 int len;
593
594 if(get_user(len,optlen))
595 return -EFAULT;
596 if(len < 0)
597 return -EINVAL;
598
599 switch(optname)
600 {
601 case SO_DEBUG:
602 v.val = sock_flag(sk, SOCK_DBG);
603 break;
604
605 case SO_DONTROUTE:
606 v.val = sock_flag(sk, SOCK_LOCALROUTE);
607 break;
608
609 case SO_BROADCAST:
610 v.val = !!sock_flag(sk, SOCK_BROADCAST);
611 break;
612
613 case SO_SNDBUF:
614 v.val = sk->sk_sndbuf;
615 break;
616
617 case SO_RCVBUF:
618 v.val = sk->sk_rcvbuf;
619 break;
620
621 case SO_REUSEADDR:
622 v.val = sk->sk_reuse;
623 break;
624
625 case SO_KEEPALIVE:
626 v.val = !!sock_flag(sk, SOCK_KEEPOPEN);
627 break;
628
629 case SO_TYPE:
630 v.val = sk->sk_type;
631 break;
632
633 case SO_ERROR:
634 v.val = -sock_error(sk);
635 if(v.val==0)
636 v.val = xchg(&sk->sk_err_soft, 0);
637 break;
638
639 case SO_OOBINLINE:
640 v.val = !!sock_flag(sk, SOCK_URGINLINE);
641 break;
642
643 case SO_NO_CHECK:
644 v.val = sk->sk_no_check;
645 break;
646
647 case SO_PRIORITY:
648 v.val = sk->sk_priority;
649 break;
650
651 case SO_LINGER:
652 lv = sizeof(v.ling);
653 v.ling.l_onoff = !!sock_flag(sk, SOCK_LINGER);
654 v.ling.l_linger = sk->sk_lingertime / HZ;
655 break;
656
657 case SO_BSDCOMPAT:
658 sock_warn_obsolete_bsdism("getsockopt");
659 break;
660
661 case SO_TIMESTAMP:
662 v.val = sock_flag(sk, SOCK_RCVTSTAMP);
663 break;
664
665 case SO_RCVTIMEO:
666 lv=sizeof(struct timeval);
667 if (sk->sk_rcvtimeo == MAX_SCHEDULE_TIMEOUT) {
668 v.tm.tv_sec = 0;
669 v.tm.tv_usec = 0;
670 } else {
671 v.tm.tv_sec = sk->sk_rcvtimeo / HZ;
672 v.tm.tv_usec = ((sk->sk_rcvtimeo % HZ) * 1000000) / HZ;
673 }
674 break;
675
676 case SO_SNDTIMEO:
677 lv=sizeof(struct timeval);
678 if (sk->sk_sndtimeo == MAX_SCHEDULE_TIMEOUT) {
679 v.tm.tv_sec = 0;
680 v.tm.tv_usec = 0;
681 } else {
682 v.tm.tv_sec = sk->sk_sndtimeo / HZ;
683 v.tm.tv_usec = ((sk->sk_sndtimeo % HZ) * 1000000) / HZ;
684 }
685 break;
686
687 case SO_RCVLOWAT:
688 v.val = sk->sk_rcvlowat;
689 break;
690
691 case SO_SNDLOWAT:
692 v.val=1;
693 break;
694
695 case SO_PASSCRED:
696 v.val = test_bit(SOCK_PASSCRED, &sock->flags) ? 1 : 0;
697 break;
698
699 case SO_PEERCRED:
700 if (len > sizeof(sk->sk_peercred))
701 len = sizeof(sk->sk_peercred);
702 if (copy_to_user(optval, &sk->sk_peercred, len))
703 return -EFAULT;
704 goto lenout;
705
706 case SO_PEERNAME:
707 {
708 char address[128];
709
710 if (sock->ops->getname(sock, (struct sockaddr *)address, &lv, 2))
711 return -ENOTCONN;
712 if (lv < len)
713 return -EINVAL;
714 if (copy_to_user(optval, address, len))
715 return -EFAULT;
716 goto lenout;
717 }
718
719 /* Dubious BSD thing... Probably nobody even uses it, but
720 * the UNIX standard wants it for whatever reason... -DaveM
721 */
722 case SO_ACCEPTCONN:
723 v.val = sk->sk_state == TCP_LISTEN;
724 break;
725
726 case SO_PEERSEC:
727 return security_socket_getpeersec_stream(sock, optval, optlen, len);
728
729 default:
730 return(-ENOPROTOOPT);
731 }
732 if (len > lv)
733 len = lv;
734 if (copy_to_user(optval, &v, len))
735 return -EFAULT;
736 lenout:
737 if (put_user(len, optlen))
738 return -EFAULT;
739 return 0;
740 }
741
742 /**
743 * sk_alloc - All socket objects are allocated here
744 * @family: protocol family
745 * @priority: for allocation (%GFP_KERNEL, %GFP_ATOMIC, etc)
746 * @prot: struct proto associated with this new sock instance
747 * @zero_it: if we should zero the newly allocated sock
748 */
749 struct sock *sk_alloc(int family, gfp_t priority,
750 struct proto *prot, int zero_it)
751 {
752 struct sock *sk = NULL;
753 kmem_cache_t *slab = prot->slab;
754
755 if (slab != NULL)
756 sk = kmem_cache_alloc(slab, priority);
757 else
758 sk = kmalloc(prot->obj_size, priority);
759
760 if (sk) {
761 if (zero_it) {
762 memset(sk, 0, prot->obj_size);
763 sk->sk_family = family;
764 /*
765 * See comment in struct sock definition to understand
766 * why we need sk_prot_creator -acme
767 */
768 sk->sk_prot = sk->sk_prot_creator = prot;
769 sock_lock_init(sk);
770 }
771
772 if (security_sk_alloc(sk, family, priority))
773 goto out_free;
774
775 if (!try_module_get(prot->owner))
776 goto out_free;
777 }
778 return sk;
779
780 out_free:
781 if (slab != NULL)
782 kmem_cache_free(slab, sk);
783 else
784 kfree(sk);
785 return NULL;
786 }
787
788 void sk_free(struct sock *sk)
789 {
790 struct sk_filter *filter;
791 struct module *owner = sk->sk_prot_creator->owner;
792
793 if (sk->sk_destruct)
794 sk->sk_destruct(sk);
795
796 filter = sk->sk_filter;
797 if (filter) {
798 sk_filter_release(sk, filter);
799 sk->sk_filter = NULL;
800 }
801
802 sock_disable_timestamp(sk);
803
804 if (atomic_read(&sk->sk_omem_alloc))
805 printk(KERN_DEBUG "%s: optmem leakage (%d bytes) detected.\n",
806 __FUNCTION__, atomic_read(&sk->sk_omem_alloc));
807
808 security_sk_free(sk);
809 if (sk->sk_prot_creator->slab != NULL)
810 kmem_cache_free(sk->sk_prot_creator->slab, sk);
811 else
812 kfree(sk);
813 module_put(owner);
814 }
815
816 struct sock *sk_clone(const struct sock *sk, const gfp_t priority)
817 {
818 struct sock *newsk = sk_alloc(sk->sk_family, priority, sk->sk_prot, 0);
819
820 if (newsk != NULL) {
821 struct sk_filter *filter;
822
823 memcpy(newsk, sk, sk->sk_prot->obj_size);
824
825 /* SANITY */
826 sk_node_init(&newsk->sk_node);
827 sock_lock_init(newsk);
828 bh_lock_sock(newsk);
829
830 atomic_set(&newsk->sk_rmem_alloc, 0);
831 atomic_set(&newsk->sk_wmem_alloc, 0);
832 atomic_set(&newsk->sk_omem_alloc, 0);
833 skb_queue_head_init(&newsk->sk_receive_queue);
834 skb_queue_head_init(&newsk->sk_write_queue);
835 #ifdef CONFIG_NET_DMA
836 skb_queue_head_init(&newsk->sk_async_wait_queue);
837 #endif
838
839 rwlock_init(&newsk->sk_dst_lock);
840 rwlock_init(&newsk->sk_callback_lock);
841
842 newsk->sk_dst_cache = NULL;
843 newsk->sk_wmem_queued = 0;
844 newsk->sk_forward_alloc = 0;
845 newsk->sk_send_head = NULL;
846 newsk->sk_backlog.head = newsk->sk_backlog.tail = NULL;
847 newsk->sk_userlocks = sk->sk_userlocks & ~SOCK_BINDPORT_LOCK;
848
849 sock_reset_flag(newsk, SOCK_DONE);
850 skb_queue_head_init(&newsk->sk_error_queue);
851
852 filter = newsk->sk_filter;
853 if (filter != NULL)
854 sk_filter_charge(newsk, filter);
855
856 if (unlikely(xfrm_sk_clone_policy(newsk))) {
857 /* It is still raw copy of parent, so invalidate
858 * destructor and make plain sk_free() */
859 newsk->sk_destruct = NULL;
860 sk_free(newsk);
861 newsk = NULL;
862 goto out;
863 }
864
865 newsk->sk_err = 0;
866 newsk->sk_priority = 0;
867 atomic_set(&newsk->sk_refcnt, 2);
868
869 /*
870 * Increment the counter in the same struct proto as the master
871 * sock (sk_refcnt_debug_inc uses newsk->sk_prot->socks, that
872 * is the same as sk->sk_prot->socks, as this field was copied
873 * with memcpy).
874 *
875 * This _changes_ the previous behaviour, where
876 * tcp_create_openreq_child always was incrementing the
877 * equivalent to tcp_prot->socks (inet_sock_nr), so this have
878 * to be taken into account in all callers. -acme
879 */
880 sk_refcnt_debug_inc(newsk);
881 newsk->sk_socket = NULL;
882 newsk->sk_sleep = NULL;
883
884 if (newsk->sk_prot->sockets_allocated)
885 atomic_inc(newsk->sk_prot->sockets_allocated);
886 }
887 out:
888 return newsk;
889 }
890
891 EXPORT_SYMBOL_GPL(sk_clone);
892
893 void __init sk_init(void)
894 {
895 if (num_physpages <= 4096) {
896 sysctl_wmem_max = 32767;
897 sysctl_rmem_max = 32767;
898 sysctl_wmem_default = 32767;
899 sysctl_rmem_default = 32767;
900 } else if (num_physpages >= 131072) {
901 sysctl_wmem_max = 131071;
902 sysctl_rmem_max = 131071;
903 }
904 }
905
906 /*
907 * Simple resource managers for sockets.
908 */
909
910
911 /*
912 * Write buffer destructor automatically called from kfree_skb.
913 */
914 void sock_wfree(struct sk_buff *skb)
915 {
916 struct sock *sk = skb->sk;
917
918 /* In case it might be waiting for more memory. */
919 atomic_sub(skb->truesize, &sk->sk_wmem_alloc);
920 if (!sock_flag(sk, SOCK_USE_WRITE_QUEUE))
921 sk->sk_write_space(sk);
922 sock_put(sk);
923 }
924
925 /*
926 * Read buffer destructor automatically called from kfree_skb.
927 */
928 void sock_rfree(struct sk_buff *skb)
929 {
930 struct sock *sk = skb->sk;
931
932 atomic_sub(skb->truesize, &sk->sk_rmem_alloc);
933 }
934
935
936 int sock_i_uid(struct sock *sk)
937 {
938 int uid;
939
940 read_lock(&sk->sk_callback_lock);
941 uid = sk->sk_socket ? SOCK_INODE(sk->sk_socket)->i_uid : 0;
942 read_unlock(&sk->sk_callback_lock);
943 return uid;
944 }
945
946 unsigned long sock_i_ino(struct sock *sk)
947 {
948 unsigned long ino;
949
950 read_lock(&sk->sk_callback_lock);
951 ino = sk->sk_socket ? SOCK_INODE(sk->sk_socket)->i_ino : 0;
952 read_unlock(&sk->sk_callback_lock);
953 return ino;
954 }
955
956 /*
957 * Allocate a skb from the socket's send buffer.
958 */
959 struct sk_buff *sock_wmalloc(struct sock *sk, unsigned long size, int force,
960 gfp_t priority)
961 {
962 if (force || atomic_read(&sk->sk_wmem_alloc) < sk->sk_sndbuf) {
963 struct sk_buff * skb = alloc_skb(size, priority);
964 if (skb) {
965 skb_set_owner_w(skb, sk);
966 return skb;
967 }
968 }
969 return NULL;
970 }
971
972 /*
973 * Allocate a skb from the socket's receive buffer.
974 */
975 struct sk_buff *sock_rmalloc(struct sock *sk, unsigned long size, int force,
976 gfp_t priority)
977 {
978 if (force || atomic_read(&sk->sk_rmem_alloc) < sk->sk_rcvbuf) {
979 struct sk_buff *skb = alloc_skb(size, priority);
980 if (skb) {
981 skb_set_owner_r(skb, sk);
982 return skb;
983 }
984 }
985 return NULL;
986 }
987
988 /*
989 * Allocate a memory block from the socket's option memory buffer.
990 */
991 void *sock_kmalloc(struct sock *sk, int size, gfp_t priority)
992 {
993 if ((unsigned)size <= sysctl_optmem_max &&
994 atomic_read(&sk->sk_omem_alloc) + size < sysctl_optmem_max) {
995 void *mem;
996 /* First do the add, to avoid the race if kmalloc
997 * might sleep.
998 */
999 atomic_add(size, &sk->sk_omem_alloc);
1000 mem = kmalloc(size, priority);
1001 if (mem)
1002 return mem;
1003 atomic_sub(size, &sk->sk_omem_alloc);
1004 }
1005 return NULL;
1006 }
1007
1008 /*
1009 * Free an option memory block.
1010 */
1011 void sock_kfree_s(struct sock *sk, void *mem, int size)
1012 {
1013 kfree(mem);
1014 atomic_sub(size, &sk->sk_omem_alloc);
1015 }
1016
1017 /* It is almost wait_for_tcp_memory minus release_sock/lock_sock.
1018 I think, these locks should be removed for datagram sockets.
1019 */
1020 static long sock_wait_for_wmem(struct sock * sk, long timeo)
1021 {
1022 DEFINE_WAIT(wait);
1023
1024 clear_bit(SOCK_ASYNC_NOSPACE, &sk->sk_socket->flags);
1025 for (;;) {
1026 if (!timeo)
1027 break;
1028 if (signal_pending(current))
1029 break;
1030 set_bit(SOCK_NOSPACE, &sk->sk_socket->flags);
1031 prepare_to_wait(sk->sk_sleep, &wait, TASK_INTERRUPTIBLE);
1032 if (atomic_read(&sk->sk_wmem_alloc) < sk->sk_sndbuf)
1033 break;
1034 if (sk->sk_shutdown & SEND_SHUTDOWN)
1035 break;
1036 if (sk->sk_err)
1037 break;
1038 timeo = schedule_timeout(timeo);
1039 }
1040 finish_wait(sk->sk_sleep, &wait);
1041 return timeo;
1042 }
1043
1044
1045 /*
1046 * Generic send/receive buffer handlers
1047 */
1048
1049 static struct sk_buff *sock_alloc_send_pskb(struct sock *sk,
1050 unsigned long header_len,
1051 unsigned long data_len,
1052 int noblock, int *errcode)
1053 {
1054 struct sk_buff *skb;
1055 gfp_t gfp_mask;
1056 long timeo;
1057 int err;
1058
1059 gfp_mask = sk->sk_allocation;
1060 if (gfp_mask & __GFP_WAIT)
1061 gfp_mask |= __GFP_REPEAT;
1062
1063 timeo = sock_sndtimeo(sk, noblock);
1064 while (1) {
1065 err = sock_error(sk);
1066 if (err != 0)
1067 goto failure;
1068
1069 err = -EPIPE;
1070 if (sk->sk_shutdown & SEND_SHUTDOWN)
1071 goto failure;
1072
1073 if (atomic_read(&sk->sk_wmem_alloc) < sk->sk_sndbuf) {
1074 skb = alloc_skb(header_len, sk->sk_allocation);
1075 if (skb) {
1076 int npages;
1077 int i;
1078
1079 /* No pages, we're done... */
1080 if (!data_len)
1081 break;
1082
1083 npages = (data_len + (PAGE_SIZE - 1)) >> PAGE_SHIFT;
1084 skb->truesize += data_len;
1085 skb_shinfo(skb)->nr_frags = npages;
1086 for (i = 0; i < npages; i++) {
1087 struct page *page;
1088 skb_frag_t *frag;
1089
1090 page = alloc_pages(sk->sk_allocation, 0);
1091 if (!page) {
1092 err = -ENOBUFS;
1093 skb_shinfo(skb)->nr_frags = i;
1094 kfree_skb(skb);
1095 goto failure;
1096 }
1097
1098 frag = &skb_shinfo(skb)->frags[i];
1099 frag->page = page;
1100 frag->page_offset = 0;
1101 frag->size = (data_len >= PAGE_SIZE ?
1102 PAGE_SIZE :
1103 data_len);
1104 data_len -= PAGE_SIZE;
1105 }
1106
1107 /* Full success... */
1108 break;
1109 }
1110 err = -ENOBUFS;
1111 goto failure;
1112 }
1113 set_bit(SOCK_ASYNC_NOSPACE, &sk->sk_socket->flags);
1114 set_bit(SOCK_NOSPACE, &sk->sk_socket->flags);
1115 err = -EAGAIN;
1116 if (!timeo)
1117 goto failure;
1118 if (signal_pending(current))
1119 goto interrupted;
1120 timeo = sock_wait_for_wmem(sk, timeo);
1121 }
1122
1123 skb_set_owner_w(skb, sk);
1124 return skb;
1125
1126 interrupted:
1127 err = sock_intr_errno(timeo);
1128 failure:
1129 *errcode = err;
1130 return NULL;
1131 }
1132
1133 struct sk_buff *sock_alloc_send_skb(struct sock *sk, unsigned long size,
1134 int noblock, int *errcode)
1135 {
1136 return sock_alloc_send_pskb(sk, size, 0, noblock, errcode);
1137 }
1138
1139 static void __lock_sock(struct sock *sk)
1140 {
1141 DEFINE_WAIT(wait);
1142
1143 for(;;) {
1144 prepare_to_wait_exclusive(&sk->sk_lock.wq, &wait,
1145 TASK_UNINTERRUPTIBLE);
1146 spin_unlock_bh(&sk->sk_lock.slock);
1147 schedule();
1148 spin_lock_bh(&sk->sk_lock.slock);
1149 if(!sock_owned_by_user(sk))
1150 break;
1151 }
1152 finish_wait(&sk->sk_lock.wq, &wait);
1153 }
1154
1155 static void __release_sock(struct sock *sk)
1156 {
1157 struct sk_buff *skb = sk->sk_backlog.head;
1158
1159 do {
1160 sk->sk_backlog.head = sk->sk_backlog.tail = NULL;
1161 bh_unlock_sock(sk);
1162
1163 do {
1164 struct sk_buff *next = skb->next;
1165
1166 skb->next = NULL;
1167 sk->sk_backlog_rcv(sk, skb);
1168
1169 /*
1170 * We are in process context here with softirqs
1171 * disabled, use cond_resched_softirq() to preempt.
1172 * This is safe to do because we've taken the backlog
1173 * queue private:
1174 */
1175 cond_resched_softirq();
1176
1177 skb = next;
1178 } while (skb != NULL);
1179
1180 bh_lock_sock(sk);
1181 } while((skb = sk->sk_backlog.head) != NULL);
1182 }
1183
1184 /**
1185 * sk_wait_data - wait for data to arrive at sk_receive_queue
1186 * @sk: sock to wait on
1187 * @timeo: for how long
1188 *
1189 * Now socket state including sk->sk_err is changed only under lock,
1190 * hence we may omit checks after joining wait queue.
1191 * We check receive queue before schedule() only as optimization;
1192 * it is very likely that release_sock() added new data.
1193 */
1194 int sk_wait_data(struct sock *sk, long *timeo)
1195 {
1196 int rc;
1197 DEFINE_WAIT(wait);
1198
1199 prepare_to_wait(sk->sk_sleep, &wait, TASK_INTERRUPTIBLE);
1200 set_bit(SOCK_ASYNC_WAITDATA, &sk->sk_socket->flags);
1201 rc = sk_wait_event(sk, timeo, !skb_queue_empty(&sk->sk_receive_queue));
1202 clear_bit(SOCK_ASYNC_WAITDATA, &sk->sk_socket->flags);
1203 finish_wait(sk->sk_sleep, &wait);
1204 return rc;
1205 }
1206
1207 EXPORT_SYMBOL(sk_wait_data);
1208
1209 /*
1210 * Set of default routines for initialising struct proto_ops when
1211 * the protocol does not support a particular function. In certain
1212 * cases where it makes no sense for a protocol to have a "do nothing"
1213 * function, some default processing is provided.
1214 */
1215
1216 int sock_no_bind(struct socket *sock, struct sockaddr *saddr, int len)
1217 {
1218 return -EOPNOTSUPP;
1219 }
1220
1221 int sock_no_connect(struct socket *sock, struct sockaddr *saddr,
1222 int len, int flags)
1223 {
1224 return -EOPNOTSUPP;
1225 }
1226
1227 int sock_no_socketpair(struct socket *sock1, struct socket *sock2)
1228 {
1229 return -EOPNOTSUPP;
1230 }
1231
1232 int sock_no_accept(struct socket *sock, struct socket *newsock, int flags)
1233 {
1234 return -EOPNOTSUPP;
1235 }
1236
1237 int sock_no_getname(struct socket *sock, struct sockaddr *saddr,
1238 int *len, int peer)
1239 {
1240 return -EOPNOTSUPP;
1241 }
1242
1243 unsigned int sock_no_poll(struct file * file, struct socket *sock, poll_table *pt)
1244 {
1245 return 0;
1246 }
1247
1248 int sock_no_ioctl(struct socket *sock, unsigned int cmd, unsigned long arg)
1249 {
1250 return -EOPNOTSUPP;
1251 }
1252
1253 int sock_no_listen(struct socket *sock, int backlog)
1254 {
1255 return -EOPNOTSUPP;
1256 }
1257
1258 int sock_no_shutdown(struct socket *sock, int how)
1259 {
1260 return -EOPNOTSUPP;
1261 }
1262
1263 int sock_no_setsockopt(struct socket *sock, int level, int optname,
1264 char __user *optval, int optlen)
1265 {
1266 return -EOPNOTSUPP;
1267 }
1268
1269 int sock_no_getsockopt(struct socket *sock, int level, int optname,
1270 char __user *optval, int __user *optlen)
1271 {
1272 return -EOPNOTSUPP;
1273 }
1274
1275 int sock_no_sendmsg(struct kiocb *iocb, struct socket *sock, struct msghdr *m,
1276 size_t len)
1277 {
1278 return -EOPNOTSUPP;
1279 }
1280
1281 int sock_no_recvmsg(struct kiocb *iocb, struct socket *sock, struct msghdr *m,
1282 size_t len, int flags)
1283 {
1284 return -EOPNOTSUPP;
1285 }
1286
1287 int sock_no_mmap(struct file *file, struct socket *sock, struct vm_area_struct *vma)
1288 {
1289 /* Mirror missing mmap method error code */
1290 return -ENODEV;
1291 }
1292
1293 ssize_t sock_no_sendpage(struct socket *sock, struct page *page, int offset, size_t size, int flags)
1294 {
1295 ssize_t res;
1296 struct msghdr msg = {.msg_flags = flags};
1297 struct kvec iov;
1298 char *kaddr = kmap(page);
1299 iov.iov_base = kaddr + offset;
1300 iov.iov_len = size;
1301 res = kernel_sendmsg(sock, &msg, &iov, 1, size);
1302 kunmap(page);
1303 return res;
1304 }
1305
1306 /*
1307 * Default Socket Callbacks
1308 */
1309
1310 static void sock_def_wakeup(struct sock *sk)
1311 {
1312 read_lock(&sk->sk_callback_lock);
1313 if (sk->sk_sleep && waitqueue_active(sk->sk_sleep))
1314 wake_up_interruptible_all(sk->sk_sleep);
1315 read_unlock(&sk->sk_callback_lock);
1316 }
1317
1318 static void sock_def_error_report(struct sock *sk)
1319 {
1320 read_lock(&sk->sk_callback_lock);
1321 if (sk->sk_sleep && waitqueue_active(sk->sk_sleep))
1322 wake_up_interruptible(sk->sk_sleep);
1323 sk_wake_async(sk,0,POLL_ERR);
1324 read_unlock(&sk->sk_callback_lock);
1325 }
1326
1327 static void sock_def_readable(struct sock *sk, int len)
1328 {
1329 read_lock(&sk->sk_callback_lock);
1330 if (sk->sk_sleep && waitqueue_active(sk->sk_sleep))
1331 wake_up_interruptible(sk->sk_sleep);
1332 sk_wake_async(sk,1,POLL_IN);
1333 read_unlock(&sk->sk_callback_lock);
1334 }
1335
1336 static void sock_def_write_space(struct sock *sk)
1337 {
1338 read_lock(&sk->sk_callback_lock);
1339
1340 /* Do not wake up a writer until he can make "significant"
1341 * progress. --DaveM
1342 */
1343 if((atomic_read(&sk->sk_wmem_alloc) << 1) <= sk->sk_sndbuf) {
1344 if (sk->sk_sleep && waitqueue_active(sk->sk_sleep))
1345 wake_up_interruptible(sk->sk_sleep);
1346
1347 /* Should agree with poll, otherwise some programs break */
1348 if (sock_writeable(sk))
1349 sk_wake_async(sk, 2, POLL_OUT);
1350 }
1351
1352 read_unlock(&sk->sk_callback_lock);
1353 }
1354
1355 static void sock_def_destruct(struct sock *sk)
1356 {
1357 kfree(sk->sk_protinfo);
1358 }
1359
1360 void sk_send_sigurg(struct sock *sk)
1361 {
1362 if (sk->sk_socket && sk->sk_socket->file)
1363 if (send_sigurg(&sk->sk_socket->file->f_owner))
1364 sk_wake_async(sk, 3, POLL_PRI);
1365 }
1366
1367 void sk_reset_timer(struct sock *sk, struct timer_list* timer,
1368 unsigned long expires)
1369 {
1370 if (!mod_timer(timer, expires))
1371 sock_hold(sk);
1372 }
1373
1374 EXPORT_SYMBOL(sk_reset_timer);
1375
1376 void sk_stop_timer(struct sock *sk, struct timer_list* timer)
1377 {
1378 if (timer_pending(timer) && del_timer(timer))
1379 __sock_put(sk);
1380 }
1381
1382 EXPORT_SYMBOL(sk_stop_timer);
1383
1384 void sock_init_data(struct socket *sock, struct sock *sk)
1385 {
1386 skb_queue_head_init(&sk->sk_receive_queue);
1387 skb_queue_head_init(&sk->sk_write_queue);
1388 skb_queue_head_init(&sk->sk_error_queue);
1389 #ifdef CONFIG_NET_DMA
1390 skb_queue_head_init(&sk->sk_async_wait_queue);
1391 #endif
1392
1393 sk->sk_send_head = NULL;
1394
1395 init_timer(&sk->sk_timer);
1396
1397 sk->sk_allocation = GFP_KERNEL;
1398 sk->sk_rcvbuf = sysctl_rmem_default;
1399 sk->sk_sndbuf = sysctl_wmem_default;
1400 sk->sk_state = TCP_CLOSE;
1401 sk->sk_socket = sock;
1402
1403 sock_set_flag(sk, SOCK_ZAPPED);
1404
1405 if(sock)
1406 {
1407 sk->sk_type = sock->type;
1408 sk->sk_sleep = &sock->wait;
1409 sock->sk = sk;
1410 } else
1411 sk->sk_sleep = NULL;
1412
1413 rwlock_init(&sk->sk_dst_lock);
1414 rwlock_init(&sk->sk_callback_lock);
1415
1416 sk->sk_state_change = sock_def_wakeup;
1417 sk->sk_data_ready = sock_def_readable;
1418 sk->sk_write_space = sock_def_write_space;
1419 sk->sk_error_report = sock_def_error_report;
1420 sk->sk_destruct = sock_def_destruct;
1421
1422 sk->sk_sndmsg_page = NULL;
1423 sk->sk_sndmsg_off = 0;
1424
1425 sk->sk_peercred.pid = 0;
1426 sk->sk_peercred.uid = -1;
1427 sk->sk_peercred.gid = -1;
1428 sk->sk_write_pending = 0;
1429 sk->sk_rcvlowat = 1;
1430 sk->sk_rcvtimeo = MAX_SCHEDULE_TIMEOUT;
1431 sk->sk_sndtimeo = MAX_SCHEDULE_TIMEOUT;
1432
1433 sk->sk_stamp.tv_sec = -1L;
1434 sk->sk_stamp.tv_usec = -1L;
1435
1436 atomic_set(&sk->sk_refcnt, 1);
1437 }
1438
1439 void fastcall lock_sock(struct sock *sk)
1440 {
1441 might_sleep();
1442 spin_lock_bh(&(sk->sk_lock.slock));
1443 if (sk->sk_lock.owner)
1444 __lock_sock(sk);
1445 sk->sk_lock.owner = (void *)1;
1446 spin_unlock_bh(&(sk->sk_lock.slock));
1447 }
1448
1449 EXPORT_SYMBOL(lock_sock);
1450
1451 void fastcall release_sock(struct sock *sk)
1452 {
1453 spin_lock_bh(&(sk->sk_lock.slock));
1454 if (sk->sk_backlog.tail)
1455 __release_sock(sk);
1456 sk->sk_lock.owner = NULL;
1457 if (waitqueue_active(&(sk->sk_lock.wq)))
1458 wake_up(&(sk->sk_lock.wq));
1459 spin_unlock_bh(&(sk->sk_lock.slock));
1460 }
1461 EXPORT_SYMBOL(release_sock);
1462
1463 int sock_get_timestamp(struct sock *sk, struct timeval __user *userstamp)
1464 {
1465 if (!sock_flag(sk, SOCK_TIMESTAMP))
1466 sock_enable_timestamp(sk);
1467 if (sk->sk_stamp.tv_sec == -1)
1468 return -ENOENT;
1469 if (sk->sk_stamp.tv_sec == 0)
1470 do_gettimeofday(&sk->sk_stamp);
1471 return copy_to_user(userstamp, &sk->sk_stamp, sizeof(struct timeval)) ?
1472 -EFAULT : 0;
1473 }
1474 EXPORT_SYMBOL(sock_get_timestamp);
1475
1476 void sock_enable_timestamp(struct sock *sk)
1477 {
1478 if (!sock_flag(sk, SOCK_TIMESTAMP)) {
1479 sock_set_flag(sk, SOCK_TIMESTAMP);
1480 net_enable_timestamp();
1481 }
1482 }
1483 EXPORT_SYMBOL(sock_enable_timestamp);
1484
1485 /*
1486 * Get a socket option on an socket.
1487 *
1488 * FIX: POSIX 1003.1g is very ambiguous here. It states that
1489 * asynchronous errors should be reported by getsockopt. We assume
1490 * this means if you specify SO_ERROR (otherwise whats the point of it).
1491 */
1492 int sock_common_getsockopt(struct socket *sock, int level, int optname,
1493 char __user *optval, int __user *optlen)
1494 {
1495 struct sock *sk = sock->sk;
1496
1497 return sk->sk_prot->getsockopt(sk, level, optname, optval, optlen);
1498 }
1499
1500 EXPORT_SYMBOL(sock_common_getsockopt);
1501
1502 #ifdef CONFIG_COMPAT
1503 int compat_sock_common_getsockopt(struct socket *sock, int level, int optname,
1504 char __user *optval, int __user *optlen)
1505 {
1506 struct sock *sk = sock->sk;
1507
1508 if (sk->sk_prot->compat_setsockopt != NULL)
1509 return sk->sk_prot->compat_getsockopt(sk, level, optname,
1510 optval, optlen);
1511 return sk->sk_prot->getsockopt(sk, level, optname, optval, optlen);
1512 }
1513 EXPORT_SYMBOL(compat_sock_common_getsockopt);
1514 #endif
1515
1516 int sock_common_recvmsg(struct kiocb *iocb, struct socket *sock,
1517 struct msghdr *msg, size_t size, int flags)
1518 {
1519 struct sock *sk = sock->sk;
1520 int addr_len = 0;
1521 int err;
1522
1523 err = sk->sk_prot->recvmsg(iocb, sk, msg, size, flags & MSG_DONTWAIT,
1524 flags & ~MSG_DONTWAIT, &addr_len);
1525 if (err >= 0)
1526 msg->msg_namelen = addr_len;
1527 return err;
1528 }
1529
1530 EXPORT_SYMBOL(sock_common_recvmsg);
1531
1532 /*
1533 * Set socket options on an inet socket.
1534 */
1535 int sock_common_setsockopt(struct socket *sock, int level, int optname,
1536 char __user *optval, int optlen)
1537 {
1538 struct sock *sk = sock->sk;
1539
1540 return sk->sk_prot->setsockopt(sk, level, optname, optval, optlen);
1541 }
1542
1543 EXPORT_SYMBOL(sock_common_setsockopt);
1544
1545 #ifdef CONFIG_COMPAT
1546 int compat_sock_common_setsockopt(struct socket *sock, int level, int optname,
1547 char __user *optval, int optlen)
1548 {
1549 struct sock *sk = sock->sk;
1550
1551 if (sk->sk_prot->compat_setsockopt != NULL)
1552 return sk->sk_prot->compat_setsockopt(sk, level, optname,
1553 optval, optlen);
1554 return sk->sk_prot->setsockopt(sk, level, optname, optval, optlen);
1555 }
1556 EXPORT_SYMBOL(compat_sock_common_setsockopt);
1557 #endif
1558
1559 void sk_common_release(struct sock *sk)
1560 {
1561 if (sk->sk_prot->destroy)
1562 sk->sk_prot->destroy(sk);
1563
1564 /*
1565 * Observation: when sock_common_release is called, processes have
1566 * no access to socket. But net still has.
1567 * Step one, detach it from networking:
1568 *
1569 * A. Remove from hash tables.
1570 */
1571
1572 sk->sk_prot->unhash(sk);
1573
1574 /*
1575 * In this point socket cannot receive new packets, but it is possible
1576 * that some packets are in flight because some CPU runs receiver and
1577 * did hash table lookup before we unhashed socket. They will achieve
1578 * receive queue and will be purged by socket destructor.
1579 *
1580 * Also we still have packets pending on receive queue and probably,
1581 * our own packets waiting in device queues. sock_destroy will drain
1582 * receive queue, but transmitted packets will delay socket destruction
1583 * until the last reference will be released.
1584 */
1585
1586 sock_orphan(sk);
1587
1588 xfrm_sk_free_policy(sk);
1589
1590 sk_refcnt_debug_release(sk);
1591 sock_put(sk);
1592 }
1593
1594 EXPORT_SYMBOL(sk_common_release);
1595
1596 static DEFINE_RWLOCK(proto_list_lock);
1597 static LIST_HEAD(proto_list);
1598
1599 int proto_register(struct proto *prot, int alloc_slab)
1600 {
1601 char *request_sock_slab_name = NULL;
1602 char *timewait_sock_slab_name;
1603 int rc = -ENOBUFS;
1604
1605 if (alloc_slab) {
1606 prot->slab = kmem_cache_create(prot->name, prot->obj_size, 0,
1607 SLAB_HWCACHE_ALIGN, NULL, NULL);
1608
1609 if (prot->slab == NULL) {
1610 printk(KERN_CRIT "%s: Can't create sock SLAB cache!\n",
1611 prot->name);
1612 goto out;
1613 }
1614
1615 if (prot->rsk_prot != NULL) {
1616 static const char mask[] = "request_sock_%s";
1617
1618 request_sock_slab_name = kmalloc(strlen(prot->name) + sizeof(mask) - 1, GFP_KERNEL);
1619 if (request_sock_slab_name == NULL)
1620 goto out_free_sock_slab;
1621
1622 sprintf(request_sock_slab_name, mask, prot->name);
1623 prot->rsk_prot->slab = kmem_cache_create(request_sock_slab_name,
1624 prot->rsk_prot->obj_size, 0,
1625 SLAB_HWCACHE_ALIGN, NULL, NULL);
1626
1627 if (prot->rsk_prot->slab == NULL) {
1628 printk(KERN_CRIT "%s: Can't create request sock SLAB cache!\n",
1629 prot->name);
1630 goto out_free_request_sock_slab_name;
1631 }
1632 }
1633
1634 if (prot->twsk_prot != NULL) {
1635 static const char mask[] = "tw_sock_%s";
1636
1637 timewait_sock_slab_name = kmalloc(strlen(prot->name) + sizeof(mask) - 1, GFP_KERNEL);
1638
1639 if (timewait_sock_slab_name == NULL)
1640 goto out_free_request_sock_slab;
1641
1642 sprintf(timewait_sock_slab_name, mask, prot->name);
1643 prot->twsk_prot->twsk_slab =
1644 kmem_cache_create(timewait_sock_slab_name,
1645 prot->twsk_prot->twsk_obj_size,
1646 0, SLAB_HWCACHE_ALIGN,
1647 NULL, NULL);
1648 if (prot->twsk_prot->twsk_slab == NULL)
1649 goto out_free_timewait_sock_slab_name;
1650 }
1651 }
1652
1653 write_lock(&proto_list_lock);
1654 list_add(&prot->node, &proto_list);
1655 write_unlock(&proto_list_lock);
1656 rc = 0;
1657 out:
1658 return rc;
1659 out_free_timewait_sock_slab_name:
1660 kfree(timewait_sock_slab_name);
1661 out_free_request_sock_slab:
1662 if (prot->rsk_prot && prot->rsk_prot->slab) {
1663 kmem_cache_destroy(prot->rsk_prot->slab);
1664 prot->rsk_prot->slab = NULL;
1665 }
1666 out_free_request_sock_slab_name:
1667 kfree(request_sock_slab_name);
1668 out_free_sock_slab:
1669 kmem_cache_destroy(prot->slab);
1670 prot->slab = NULL;
1671 goto out;
1672 }
1673
1674 EXPORT_SYMBOL(proto_register);
1675
1676 void proto_unregister(struct proto *prot)
1677 {
1678 write_lock(&proto_list_lock);
1679 list_del(&prot->node);
1680 write_unlock(&proto_list_lock);
1681
1682 if (prot->slab != NULL) {
1683 kmem_cache_destroy(prot->slab);
1684 prot->slab = NULL;
1685 }
1686
1687 if (prot->rsk_prot != NULL && prot->rsk_prot->slab != NULL) {
1688 const char *name = kmem_cache_name(prot->rsk_prot->slab);
1689
1690 kmem_cache_destroy(prot->rsk_prot->slab);
1691 kfree(name);
1692 prot->rsk_prot->slab = NULL;
1693 }
1694
1695 if (prot->twsk_prot != NULL && prot->twsk_prot->twsk_slab != NULL) {
1696 const char *name = kmem_cache_name(prot->twsk_prot->twsk_slab);
1697
1698 kmem_cache_destroy(prot->twsk_prot->twsk_slab);
1699 kfree(name);
1700 prot->twsk_prot->twsk_slab = NULL;
1701 }
1702 }
1703
1704 EXPORT_SYMBOL(proto_unregister);
1705
1706 #ifdef CONFIG_PROC_FS
1707 static inline struct proto *__proto_head(void)
1708 {
1709 return list_entry(proto_list.next, struct proto, node);
1710 }
1711
1712 static inline struct proto *proto_head(void)
1713 {
1714 return list_empty(&proto_list) ? NULL : __proto_head();
1715 }
1716
1717 static inline struct proto *proto_next(struct proto *proto)
1718 {
1719 return proto->node.next == &proto_list ? NULL :
1720 list_entry(proto->node.next, struct proto, node);
1721 }
1722
1723 static inline struct proto *proto_get_idx(loff_t pos)
1724 {
1725 struct proto *proto;
1726 loff_t i = 0;
1727
1728 list_for_each_entry(proto, &proto_list, node)
1729 if (i++ == pos)
1730 goto out;
1731
1732 proto = NULL;
1733 out:
1734 return proto;
1735 }
1736
1737 static void *proto_seq_start(struct seq_file *seq, loff_t *pos)
1738 {
1739 read_lock(&proto_list_lock);
1740 return *pos ? proto_get_idx(*pos - 1) : SEQ_START_TOKEN;
1741 }
1742
1743 static void *proto_seq_next(struct seq_file *seq, void *v, loff_t *pos)
1744 {
1745 ++*pos;
1746 return v == SEQ_START_TOKEN ? proto_head() : proto_next(v);
1747 }
1748
1749 static void proto_seq_stop(struct seq_file *seq, void *v)
1750 {
1751 read_unlock(&proto_list_lock);
1752 }
1753
1754 static char proto_method_implemented(const void *method)
1755 {
1756 return method == NULL ? 'n' : 'y';
1757 }
1758
1759 static void proto_seq_printf(struct seq_file *seq, struct proto *proto)
1760 {
1761 seq_printf(seq, "%-9s %4u %6d %6d %-3s %6u %-3s %-10s "
1762 "%2c %2c %2c %2c %2c %2c %2c %2c %2c %2c %2c %2c %2c %2c %2c %2c %2c %2c %2c\n",
1763 proto->name,
1764 proto->obj_size,
1765 proto->sockets_allocated != NULL ? atomic_read(proto->sockets_allocated) : -1,
1766 proto->memory_allocated != NULL ? atomic_read(proto->memory_allocated) : -1,
1767 proto->memory_pressure != NULL ? *proto->memory_pressure ? "yes" : "no" : "NI",
1768 proto->max_header,
1769 proto->slab == NULL ? "no" : "yes",
1770 module_name(proto->owner),
1771 proto_method_implemented(proto->close),
1772 proto_method_implemented(proto->connect),
1773 proto_method_implemented(proto->disconnect),
1774 proto_method_implemented(proto->accept),
1775 proto_method_implemented(proto->ioctl),
1776 proto_method_implemented(proto->init),
1777 proto_method_implemented(proto->destroy),
1778 proto_method_implemented(proto->shutdown),
1779 proto_method_implemented(proto->setsockopt),
1780 proto_method_implemented(proto->getsockopt),
1781 proto_method_implemented(proto->sendmsg),
1782 proto_method_implemented(proto->recvmsg),
1783 proto_method_implemented(proto->sendpage),
1784 proto_method_implemented(proto->bind),
1785 proto_method_implemented(proto->backlog_rcv),
1786 proto_method_implemented(proto->hash),
1787 proto_method_implemented(proto->unhash),
1788 proto_method_implemented(proto->get_port),
1789 proto_method_implemented(proto->enter_memory_pressure));
1790 }
1791
1792 static int proto_seq_show(struct seq_file *seq, void *v)
1793 {
1794 if (v == SEQ_START_TOKEN)
1795 seq_printf(seq, "%-9s %-4s %-8s %-6s %-5s %-7s %-4s %-10s %s",
1796 "protocol",
1797 "size",
1798 "sockets",
1799 "memory",
1800 "press",
1801 "maxhdr",
1802 "slab",
1803 "module",
1804 "cl co di ac io in de sh ss gs se re sp bi br ha uh gp em\n");
1805 else
1806 proto_seq_printf(seq, v);
1807 return 0;
1808 }
1809
1810 static struct seq_operations proto_seq_ops = {
1811 .start = proto_seq_start,
1812 .next = proto_seq_next,
1813 .stop = proto_seq_stop,
1814 .show = proto_seq_show,
1815 };
1816
1817 static int proto_seq_open(struct inode *inode, struct file *file)
1818 {
1819 return seq_open(file, &proto_seq_ops);
1820 }
1821
1822 static struct file_operations proto_seq_fops = {
1823 .owner = THIS_MODULE,
1824 .open = proto_seq_open,
1825 .read = seq_read,
1826 .llseek = seq_lseek,
1827 .release = seq_release,
1828 };
1829
1830 static int __init proto_init(void)
1831 {
1832 /* register /proc/net/protocols */
1833 return proc_net_fops_create("protocols", S_IRUGO, &proto_seq_fops) == NULL ? -ENOBUFS : 0;
1834 }
1835
1836 subsys_initcall(proto_init);
1837
1838 #endif /* PROC_FS */
1839
1840 EXPORT_SYMBOL(sk_alloc);
1841 EXPORT_SYMBOL(sk_free);
1842 EXPORT_SYMBOL(sk_send_sigurg);
1843 EXPORT_SYMBOL(sock_alloc_send_skb);
1844 EXPORT_SYMBOL(sock_init_data);
1845 EXPORT_SYMBOL(sock_kfree_s);
1846 EXPORT_SYMBOL(sock_kmalloc);
1847 EXPORT_SYMBOL(sock_no_accept);
1848 EXPORT_SYMBOL(sock_no_bind);
1849 EXPORT_SYMBOL(sock_no_connect);
1850 EXPORT_SYMBOL(sock_no_getname);
1851 EXPORT_SYMBOL(sock_no_getsockopt);
1852 EXPORT_SYMBOL(sock_no_ioctl);
1853 EXPORT_SYMBOL(sock_no_listen);
1854 EXPORT_SYMBOL(sock_no_mmap);
1855 EXPORT_SYMBOL(sock_no_poll);
1856 EXPORT_SYMBOL(sock_no_recvmsg);
1857 EXPORT_SYMBOL(sock_no_sendmsg);
1858 EXPORT_SYMBOL(sock_no_sendpage);
1859 EXPORT_SYMBOL(sock_no_setsockopt);
1860 EXPORT_SYMBOL(sock_no_shutdown);
1861 EXPORT_SYMBOL(sock_no_socketpair);
1862 EXPORT_SYMBOL(sock_rfree);
1863 EXPORT_SYMBOL(sock_setsockopt);
1864 EXPORT_SYMBOL(sock_wfree);
1865 EXPORT_SYMBOL(sock_wmalloc);
1866 EXPORT_SYMBOL(sock_i_uid);
1867 EXPORT_SYMBOL(sock_i_ino);
1868 EXPORT_SYMBOL(sysctl_optmem_max);
1869 #ifdef CONFIG_SYSCTL
1870 EXPORT_SYMBOL(sysctl_rmem_max);
1871 EXPORT_SYMBOL(sysctl_wmem_max);
1872 #endif
Ubuntu Jammy Linux kernel mirror