Rietveld Code Review Tool
Help | Bug tracker | Discussion group | Source code | Sign in
(295)

Side by Side Diff: src/pkg/net/fd_unix.go

Issue 6850110: code review 6850110: net: move deadline logic into pollServer (Closed)
Patch Set: diff -r 34e54cf71fed https://go.googlecode.com/hg/ Created 11 years, 4 months ago
Left:
Right:
Use n/p to move between diff chunks; N/P to move between comments. Please Sign in to add in-line comments.
Jump to:
View unified diff | Download patch
« no previous file with comments | « no previous file | no next file » | no next file with comments »
Toggle Intra-line Diffs ('i') | Expand Comments ('e') | Collapse Comments ('c') | Show Comments Hide Comments ('s')
OLDNEW
1 // Copyright 2009 The Go Authors. All rights reserved. 1 // Copyright 2009 The Go Authors. All rights reserved.
2 // Use of this source code is governed by a BSD-style 2 // Use of this source code is governed by a BSD-style
3 // license that can be found in the LICENSE file. 3 // license that can be found in the LICENSE file.
4 4
5 // +build darwin freebsd linux netbsd openbsd 5 // +build darwin freebsd linux netbsd openbsd
6 6
7 package net 7 package net
8 8
9 import ( 9 import (
10 "io" 10 "io"
(...skipping 163 matching lines...) Expand 10 before | Expand all | Expand 10 after
174 if mode == 'r' { 174 if mode == 'r' {
175 t = fd.rdeadline 175 t = fd.rdeadline
176 } else { 176 } else {
177 t = fd.wdeadline 177 t = fd.wdeadline
178 } 178 }
179 if t > 0 { 179 if t > 0 {
180 if t <= now { 180 if t <= now {
181 delete(s.pending, key) 181 delete(s.pending, key)
182 if mode == 'r' { 182 if mode == 'r' {
183 s.poll.DelFD(fd.sysfd, mode) 183 s.poll.DelFD(fd.sysfd, mode)
184 fd.rdeadline = -1
185 } else { 184 } else {
186 s.poll.DelFD(fd.sysfd, mode) 185 s.poll.DelFD(fd.sysfd, mode)
187 fd.wdeadline = -1
188 } 186 }
189 » » » » s.WakeFD(fd, mode, nil) 187 » » » » s.WakeFD(fd, mode, errTimeout)
190 } else if nextDeadline == 0 || t < nextDeadline { 188 } else if nextDeadline == 0 || t < nextDeadline {
191 nextDeadline = t 189 nextDeadline = t
192 } 190 }
193 } 191 }
194 } 192 }
195 s.deadline = nextDeadline 193 s.deadline = nextDeadline
196 } 194 }
197 195
198 func (s *pollServer) Run() { 196 func (s *pollServer) Run() {
199 var scratch [100]byte 197 var scratch [100]byte
(...skipping 122 matching lines...) Expand 10 before | Expand all | Expand 10 after
322 ls = fd.laddr.String() 320 ls = fd.laddr.String()
323 } 321 }
324 if fd.raddr != nil { 322 if fd.raddr != nil {
325 rs = fd.raddr.String() 323 rs = fd.raddr.String()
326 } 324 }
327 return fd.net + ":" + ls + "->" + rs 325 return fd.net + ":" + ls + "->" + rs
328 } 326 }
329 327
330 func (fd *netFD) connect(ra syscall.Sockaddr) error { 328 func (fd *netFD) connect(ra syscall.Sockaddr) error {
331 err := syscall.Connect(fd.sysfd, ra) 329 err := syscall.Connect(fd.sysfd, ra)
332 hadTimeout := fd.wdeadline > 0
333 if err == syscall.EINPROGRESS { 330 if err == syscall.EINPROGRESS {
334 if err = fd.pollServer.WaitWrite(fd); err != nil { 331 if err = fd.pollServer.WaitWrite(fd); err != nil {
335 return err 332 return err
336 } 333 }
337 if hadTimeout && fd.wdeadline < 0 {
338 return errTimeout
339 }
340 var e int 334 var e int
341 e, err = syscall.GetsockoptInt(fd.sysfd, syscall.SOL_SOCKET, sys call.SO_ERROR) 335 e, err = syscall.GetsockoptInt(fd.sysfd, syscall.SOL_SOCKET, sys call.SO_ERROR)
342 if err != nil { 336 if err != nil {
343 return os.NewSyscallError("getsockopt", err) 337 return os.NewSyscallError("getsockopt", err)
344 } 338 }
345 if e != 0 { 339 if e != 0 {
346 err = syscall.Errno(e) 340 err = syscall.Errno(e)
347 } 341 }
348 } 342 }
349 return err 343 return err
(...skipping 73 matching lines...) Expand 10 before | Expand all | Expand 10 after
423 } 417 }
424 defer fd.decref() 418 defer fd.decref()
425 for { 419 for {
426 if fd.rdeadline > 0 { 420 if fd.rdeadline > 0 {
427 if time.Now().UnixNano() >= fd.rdeadline { 421 if time.Now().UnixNano() >= fd.rdeadline {
428 err = errTimeout 422 err = errTimeout
429 break 423 break
430 } 424 }
431 } 425 }
432 n, err = syscall.Read(int(fd.sysfd), p) 426 n, err = syscall.Read(int(fd.sysfd), p)
433 » » if err == syscall.EAGAIN { 427 » » if err != nil {
434 n = 0 428 n = 0
435 » » » err = errTimeout 429 » » » if err == syscall.EAGAIN {
436 » » » if fd.rdeadline >= 0 {
437 if err = fd.pollServer.WaitRead(fd); err == nil { 430 if err = fd.pollServer.WaitRead(fd); err == nil {
438 continue 431 continue
439 } 432 }
440 } 433 }
441 } 434 }
442 » » if err != nil { 435 » » if n == 0 && err == nil && fd.sotype == syscall.SOCK_STREAM {
rsc 2012/11/27 15:26:58 Please change this back to != SOCK_DGRAM. This is
dfc 2012/11/27 21:35:16 Done.
443 » » » n = 0
444 » » } else if n == 0 && err == nil && fd.sotype != syscall.SOCK_DGRA M {
445 err = io.EOF 436 err = io.EOF
446 } 437 }
447 break 438 break
448 } 439 }
449 if err != nil && err != io.EOF { 440 if err != nil && err != io.EOF {
450 err = &OpError{"read", fd.net, fd.raddr, err} 441 err = &OpError{"read", fd.net, fd.raddr, err}
451 } 442 }
452 return 443 return
453 } 444 }
454 445
455 func (fd *netFD) ReadFrom(p []byte) (n int, sa syscall.Sockaddr, err error) { 446 func (fd *netFD) ReadFrom(p []byte) (n int, sa syscall.Sockaddr, err error) {
456 fd.rio.Lock() 447 fd.rio.Lock()
457 defer fd.rio.Unlock() 448 defer fd.rio.Unlock()
458 if err := fd.incref(false); err != nil { 449 if err := fd.incref(false); err != nil {
459 return 0, nil, err 450 return 0, nil, err
460 } 451 }
461 defer fd.decref() 452 defer fd.decref()
462 for { 453 for {
463 if fd.rdeadline > 0 { 454 if fd.rdeadline > 0 {
464 if time.Now().UnixNano() >= fd.rdeadline { 455 if time.Now().UnixNano() >= fd.rdeadline {
465 err = errTimeout 456 err = errTimeout
466 break 457 break
467 } 458 }
468 } 459 }
469 n, sa, err = syscall.Recvfrom(fd.sysfd, p, 0) 460 n, sa, err = syscall.Recvfrom(fd.sysfd, p, 0)
470 » » if err == syscall.EAGAIN { 461 » » if err != nil {
471 n = 0 462 n = 0
472 » » » err = errTimeout 463 » » » if err == syscall.EAGAIN {
473 » » » if fd.rdeadline >= 0 {
474 if err = fd.pollServer.WaitRead(fd); err == nil { 464 if err = fd.pollServer.WaitRead(fd); err == nil {
475 continue 465 continue
476 } 466 }
477 } 467 }
478 } 468 }
479 » » if err != nil { 469 » » if n == 0 && err == nil && fd.sotype == syscall.SOCK_STREAM {
rsc 2012/11/27 15:26:58 Same.
dfc 2012/11/27 21:35:16 Done.
480 » » » n = 0 470 » » » err = io.EOF
481 } 471 }
482 break 472 break
483 } 473 }
484 if err != nil && err != io.EOF { 474 if err != nil && err != io.EOF {
485 err = &OpError{"read", fd.net, fd.laddr, err} 475 err = &OpError{"read", fd.net, fd.laddr, err}
486 } 476 }
487 return 477 return
488 } 478 }
489 479
490 func (fd *netFD) ReadMsg(p []byte, oob []byte) (n, oobn, flags int, sa syscall.S ockaddr, err error) { 480 func (fd *netFD) ReadMsg(p []byte, oob []byte) (n, oobn, flags int, sa syscall.S ockaddr, err error) {
491 fd.rio.Lock() 481 fd.rio.Lock()
492 defer fd.rio.Unlock() 482 defer fd.rio.Unlock()
493 if err := fd.incref(false); err != nil { 483 if err := fd.incref(false); err != nil {
494 return 0, 0, 0, nil, err 484 return 0, 0, 0, nil, err
495 } 485 }
496 defer fd.decref() 486 defer fd.decref()
497 for { 487 for {
498 if fd.rdeadline > 0 { 488 if fd.rdeadline > 0 {
499 if time.Now().UnixNano() >= fd.rdeadline { 489 if time.Now().UnixNano() >= fd.rdeadline {
500 err = errTimeout 490 err = errTimeout
501 break 491 break
502 } 492 }
503 } 493 }
504 n, oobn, flags, sa, err = syscall.Recvmsg(fd.sysfd, p, oob, 0) 494 n, oobn, flags, sa, err = syscall.Recvmsg(fd.sysfd, p, oob, 0)
505 » » if err == syscall.EAGAIN { 495 » » if err != nil {
506 » » » n = 0 496 » » » // TODO(dfc) should n and oobn be set to nil
507 » » » err = errTimeout 497 » » » if err == syscall.EAGAIN {
508 » » » if fd.rdeadline >= 0 {
509 if err = fd.pollServer.WaitRead(fd); err == nil { 498 if err = fd.pollServer.WaitRead(fd); err == nil {
510 continue 499 continue
511 } 500 }
512 } 501 }
513 } 502 }
514 » » if err == nil && n == 0 { 503 » » if n == 0 && err == nil && fd.sotype == syscall.SOCK_STREAM {
rsc 2012/11/27 15:26:58 Same.
dfc 2012/11/27 21:35:16 Done.
515 err = io.EOF 504 err = io.EOF
516 } 505 }
517 break 506 break
518 } 507 }
519 if err != nil && err != io.EOF { 508 if err != nil && err != io.EOF {
520 err = &OpError{"read", fd.net, fd.laddr, err} 509 err = &OpError{"read", fd.net, fd.laddr, err}
521 return
522 } 510 }
523 return 511 return
524 } 512 }
525 513
526 func (fd *netFD) Write(p []byte) (int, error) { 514 func (fd *netFD) Write(p []byte) (int, error) {
527 fd.wio.Lock() 515 fd.wio.Lock()
528 defer fd.wio.Unlock() 516 defer fd.wio.Unlock()
529 if err := fd.incref(false); err != nil { 517 if err := fd.incref(false); err != nil {
530 return 0, err 518 return 0, err
531 } 519 }
532 defer fd.decref() 520 defer fd.decref()
533 var err error 521 var err error
534 nn := 0 522 nn := 0
535 for { 523 for {
536 if fd.wdeadline > 0 { 524 if fd.wdeadline > 0 {
537 if time.Now().UnixNano() >= fd.wdeadline { 525 if time.Now().UnixNano() >= fd.wdeadline {
538 err = errTimeout 526 err = errTimeout
539 break 527 break
540 } 528 }
541 } 529 }
542 var n int 530 var n int
543 n, err = syscall.Write(int(fd.sysfd), p[nn:]) 531 n, err = syscall.Write(int(fd.sysfd), p[nn:])
544 if n > 0 { 532 if n > 0 {
545 nn += n 533 nn += n
546 } 534 }
547 if nn == len(p) { 535 if nn == len(p) {
548 break 536 break
549 } 537 }
550 if err == syscall.EAGAIN { 538 if err == syscall.EAGAIN {
551 » » » err = errTimeout 539 » » » if err = fd.pollServer.WaitWrite(fd); err == nil {
552 » » » if fd.wdeadline >= 0 { 540 » » » » continue
553 » » » » if err = fd.pollServer.WaitWrite(fd); err == nil {
554 » » » » » continue
555 » » » » }
556 } 541 }
557 } 542 }
558 if err != nil { 543 if err != nil {
559 n = 0 544 n = 0
560 break 545 break
561 } 546 }
562 if n == 0 { 547 if n == 0 {
563 err = io.ErrUnexpectedEOF 548 err = io.ErrUnexpectedEOF
564 break 549 break
565 } 550 }
(...skipping 13 matching lines...) Expand all
579 defer fd.decref() 564 defer fd.decref()
580 for { 565 for {
581 if fd.wdeadline > 0 { 566 if fd.wdeadline > 0 {
582 if time.Now().UnixNano() >= fd.wdeadline { 567 if time.Now().UnixNano() >= fd.wdeadline {
583 err = errTimeout 568 err = errTimeout
584 break 569 break
585 } 570 }
586 } 571 }
587 err = syscall.Sendto(fd.sysfd, p, 0, sa) 572 err = syscall.Sendto(fd.sysfd, p, 0, sa)
588 if err == syscall.EAGAIN { 573 if err == syscall.EAGAIN {
589 » » » err = errTimeout 574 » » » if err = fd.pollServer.WaitWrite(fd); err == nil {
590 » » » if fd.wdeadline >= 0 { 575 » » » » continue
591 » » » » if err = fd.pollServer.WaitWrite(fd); err == nil {
592 » » » » » continue
593 » » » » }
594 } 576 }
595 } 577 }
596 break 578 break
597 } 579 }
598 if err == nil { 580 if err == nil {
599 n = len(p) 581 n = len(p)
600 } else { 582 } else {
601 err = &OpError{"write", fd.net, fd.raddr, err} 583 err = &OpError{"write", fd.net, fd.raddr, err}
602 } 584 }
603 return 585 return
604 } 586 }
605 587
606 func (fd *netFD) WriteMsg(p []byte, oob []byte, sa syscall.Sockaddr) (n int, oob n int, err error) { 588 func (fd *netFD) WriteMsg(p []byte, oob []byte, sa syscall.Sockaddr) (n int, oob n int, err error) {
607 fd.wio.Lock() 589 fd.wio.Lock()
608 defer fd.wio.Unlock() 590 defer fd.wio.Unlock()
609 if err := fd.incref(false); err != nil { 591 if err := fd.incref(false); err != nil {
610 return 0, 0, err 592 return 0, 0, err
611 } 593 }
612 defer fd.decref() 594 defer fd.decref()
613 for { 595 for {
614 if fd.wdeadline > 0 { 596 if fd.wdeadline > 0 {
615 if time.Now().UnixNano() >= fd.wdeadline { 597 if time.Now().UnixNano() >= fd.wdeadline {
616 err = errTimeout 598 err = errTimeout
617 break 599 break
618 } 600 }
619 } 601 }
620 err = syscall.Sendmsg(fd.sysfd, p, oob, sa, 0) 602 err = syscall.Sendmsg(fd.sysfd, p, oob, sa, 0)
621 if err == syscall.EAGAIN { 603 if err == syscall.EAGAIN {
622 » » » err = errTimeout 604 » » » if err = fd.pollServer.WaitWrite(fd); err == nil {
623 » » » if fd.wdeadline >= 0 { 605 » » » » continue
624 » » » » if err = fd.pollServer.WaitWrite(fd); err == nil {
625 » » » » » continue
626 » » » » }
627 } 606 }
628 } 607 }
629 break 608 break
630 } 609 }
631 if err == nil { 610 if err == nil {
632 n = len(p) 611 n = len(p)
633 oobn = len(oob) 612 oobn = len(oob)
634 } else { 613 } else {
635 err = &OpError{"write", fd.net, fd.raddr, err} 614 err = &OpError{"write", fd.net, fd.raddr, err}
636 } 615 }
(...skipping 10 matching lines...) Expand all
647 // It is okay to hold the lock across syscall.Accept 626 // It is okay to hold the lock across syscall.Accept
648 // because we have put fd.sysfd into non-blocking mode. 627 // because we have put fd.sysfd into non-blocking mode.
649 var s int 628 var s int
650 var rsa syscall.Sockaddr 629 var rsa syscall.Sockaddr
651 for { 630 for {
652 syscall.ForkLock.RLock() 631 syscall.ForkLock.RLock()
653 s, rsa, err = syscall.Accept(fd.sysfd) 632 s, rsa, err = syscall.Accept(fd.sysfd)
654 if err != nil { 633 if err != nil {
655 syscall.ForkLock.RUnlock() 634 syscall.ForkLock.RUnlock()
656 if err == syscall.EAGAIN { 635 if err == syscall.EAGAIN {
657 » » » » err = errTimeout 636 » » » » if err = fd.pollServer.WaitRead(fd); err == nil {
658 » » » » if fd.rdeadline >= 0 { 637 » » » » » continue
659 » » » » » if err = fd.pollServer.WaitRead(fd); err == nil {
660 » » » » » » continue
661 » » » » » }
662 } 638 }
663 } else if err == syscall.ECONNABORTED { 639 } else if err == syscall.ECONNABORTED {
664 // This means that a socket on the listen queue was closed 640 // This means that a socket on the listen queue was closed
665 // before we Accept()ed it; it's a silly error, so try again. 641 // before we Accept()ed it; it's a silly error, so try again.
666 continue 642 continue
667 } 643 }
668 return nil, &OpError{"accept", fd.net, fd.laddr, err} 644 return nil, &OpError{"accept", fd.net, fd.laddr, err}
669 } 645 }
670 break 646 break
671 } 647 }
(...skipping 23 matching lines...) Expand all
695 if err = syscall.SetNonblock(ns, false); err != nil { 671 if err = syscall.SetNonblock(ns, false); err != nil {
696 return nil, &OpError{"setnonblock", fd.net, fd.laddr, err} 672 return nil, &OpError{"setnonblock", fd.net, fd.laddr, err}
697 } 673 }
698 674
699 return os.NewFile(uintptr(ns), fd.name()), nil 675 return os.NewFile(uintptr(ns), fd.name()), nil
700 } 676 }
701 677
702 func closesocket(s int) error { 678 func closesocket(s int) error {
703 return syscall.Close(s) 679 return syscall.Close(s)
704 } 680 }
OLDNEW
« no previous file with comments | « no previous file | no next file » | no next file with comments »

Powered by Google App Engine
RSS Feeds Recent Issues | This issue
This is Rietveld f62528b