code review 4536076: net: Sendfile for win32.

src/pkg/net/sendfile_windows.go

 // Copyright 2011 The Go Authors.  All rights reserved.
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
 package net

[brainman, 2011/06/03 07:31:57]

It doesn't need to be so complicated (I didn't tested this code properly):

// Copyright 2011 The Go Authors.  All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

package net

import (
	"io"
	"os"
	"syscall"
)

type sendfileOp struct {
	anOp
	src int32 // source
	n   int64 // how many bytes to send (0 means till EOF)
}

func (o *sendfileOp) Submit() (errno int) {
	return syscall.TransmitFile(int32(o.fd.sysfd), o.src, uint32(o.n), 0, &o.o,
nil, 0)
}

func (o *sendfileOp) Name() string {
	return "TransmitFile"
}

// sendFile copies the contents of r to c using the TransmitFile
// system call to minimize copies.
//
// if handled == true, sendFile returns the number of bytes copied and any
// non-EOF error.
//
// if handled == false, sendFile performed no work.
func sendFile(c *netFD, r io.Reader) (written int64, err os.Error, handled bool)
{
	var n int64 = 0 // by default, copy until EOF

	lr, ok := r.(*io.LimitedReader)
	if ok {
		n, r = lr.N, lr.R
		if n <= 0 {
			return 0, nil, true
		}
	}
	f, ok := r.(*os.File)
	if !ok {
		return 0, nil, false
	}

	c.wio.Lock()
	defer c.wio.Unlock()
	c.incref()
	defer c.decref()

	var o sendfileOp
	o.Init(c)
	o.n = n
	o.src = int32(f.Fd())
	done, err := iosrv.ExecIO(&o, 0)
	if lr != nil {
		lr.N -= int64(done)
	}
	return int64(done), err, done > 0
}

[mattn, 2011/06/03 11:13:49]

Hmm, it can't send large file than 0xffffffff.

 
 import (
         "io"
         "os"
         "syscall"
 )
 
 type sendfileOp struct {
         anOp
-        src     int32 // source
-        written int64
-        remain  int64
+        src int32 // source
+        n   uint32
 }
 
 func (o *sendfileOp) Submit() (errno int) {
-        o.written = 0
-        o.o.HEvent, errno = syscall.CreateEvent(nil, false, false, nil)
-        if errno != 0 {
-                return
-        }
-        defer syscall.CloseHandle(o.o.HEvent)
-        fd := int32(o.fd.sysfd)
-        for o.remain > 0 {
-                remain := o.remain
-                if remain > 0xffffffff {
-                        remain = 0xffffffff
-                }
-                errno = syscall.TransmitFile(fd, o.src, uint32(remain), 0, &o.o, nil, syscall.TF_WRITE_BEHIND)

[brainman, 2011/06/03 07:31:57]

Brad, I take it, we start from "current position" in the file?

-                if errno == 0 {
-                        return syscall.ERROR_BAD_ARGUMENTS
-                }
-                if errno != syscall.ERROR_IO_PENDING {
-                        return errno
-                }
-                rv, errno := syscall.WaitForSingleObject(o.o.HEvent, syscall.INFINITE)

[brainman, 2011/06/07 00:30:26]

I've said it before. I'll say it again. You don't need all that waiting code
here - it is already implemented in fd_windows.go, you just need to use it.

That other code also implements "timeouts", which you don't do here.

If you need to loop, please do it inside sendFile. But according to
http://www.ms-news.net/f3603/transmitfile-file-siez-limit-2067347.html,
TransmitFile will fail for big files on some platforms regardless:
... it was not possible to solve this
issue by transmitting smaller portions of the file because
TransmitFile() failed with the same error just given a handle to file
larger than 2 GB even if the size to transmit was smaller.

<<<<

[mattn, 2011/06/07 01:21:01]

Done.

-                if errno != 0 {
-                        // WAIT_FAILED
-                        return errno
-                }
-                if rv == syscall.WAIT_TIMEOUT {
-                        return syscall.ERROR_TIMEOUT
-                }
-                if rv == syscall.WAIT_ABANDONED {
-                        return syscall.ERROR_DISCARDED
-                }
-                // WAIT_OBJECT_0
-                n := uint32(0)
-                errno = syscall.GetOverlappedResult(fd, &o.o, &n, false)
-                if errno != 0 {
-                        return errno
-                }
-                o.written += int64(n)
-                o.remain -= int64(n)
-                if o.remain <= 0 {
-                        break
-                }
-        }
-        return
+        return syscall.TransmitFile(int32(o.fd.sysfd), o.src, o.n, 0, &o.o, nil, syscall.TF_WRITE_BEHIND)
 }
 
 func (o *sendfileOp) Name() string {
         return "TransmitFile"
 }
 
 // sendFile copies the contents of r to c using the TransmitFile
 // system call to minimize copies.
 //
 // if handled == true, sendFile returns the number of bytes copied and any
 // non-EOF error.
 //
 // if handled == false, sendFile performed no work.
+//
+// Note that sendfile for windows does not suppport >2GB file.
 func sendFile(c *netFD, r io.Reader) (written int64, err os.Error, handled bool) {
-        var remain int64 = 1 << 62 // by default, copy until EOF
+        var n int64 = 0 // by default, copy until EOF
 
         lr, ok := r.(*io.LimitedReader)
         if ok {
-                remain, r = lr.N, lr.R
-                if remain <= 0 {
+                n, r = lr.N, lr.R
+                if n <= 0 {
                         return 0, nil, true
                 }
         }
         f, ok := r.(*os.File)
         if !ok {
                 return 0, nil, false
         }
 
         c.wio.Lock()
         defer c.wio.Unlock()
         c.incref()
         defer c.decref()
 
         var o sendfileOp
         o.Init(c)
-        o.remain = remain
+        o.n = uint32(n)
         o.src = int32(f.Fd())
-
-        _, err = iosrv.ExecIO(&o, 0)
+        done, err := iosrv.ExecIO(&o, 0)
+        if err != nil {
+                return 0, err, false
+        }
         if lr != nil {
-                lr.N = o.remain
+                lr.N -= int64(done)
         }
-        return o.written, err, o.written > 0
+        return int64(done), nil, true
 }