Add os/file.Truncate

src/os/file.go

@@ -283,16 +283,6 @@ func (f *File) Sync() (err error) {
 	return
 }
 
-// Truncate is a stub, not yet implemented
-func (f *File) Truncate(size int64) (err error) {
-	if f.handle == nil {
-		err = ErrClosed
-	} else {
-		err = ErrNotImplemented
-	}
-	return &PathError{Op: "truncate", Path: f.name, Err: err}
-}
-
 // LinkError records an error during a link or symlink or rename system call and
 // the paths that caused it.
 type LinkError struct {

src/os/file_unix.go

@@ -112,6 +112,26 @@ func Readlink(name string) (string, error) {
 	}
 }
 
+// Truncate changes the size of the file.
+// It does not change the I/O offset.
+// If there is an error, it will be of type *PathError.
+
+// Alternatively just use 'raw' syscall by file name
+func (f *File) Truncate(size int64) (err error) {
+	if f.handle == nil {
+		return ErrClosed
+	}
+
+	e := ignoringEINTR(func() error {
+		return syscall.Truncate(f.name, size)
+	})
+
+	if e != nil {
+		return &PathError{Op: "truncate", Path: f.name, Err: e}
+	}
+	return
+}
+
 // ReadAt reads up to len(b) bytes from the File starting at the given absolute offset.
 // It returns the number of bytes read and any error encountered, possibly io.EOF.
 // At end of file, Pread returns 0, io.EOF.

src/os/file_windows.go

@@ -59,6 +59,10 @@ func Pipe() (r *File, w *File, err error) {
 	return
 }
 
+func (f *unixFileHandle) Truncate(size int64) error {
+	return ErrNotImplemented
+}
+
 func tempDir() string {
 	n := uint32(syscall.MAX_PATH)
 	for {

src/os/truncate_test.go

@@ -0,0 +1,58 @@
+//go:build darwin || (linux && !baremetal && !js && !wasi)
+
+// Copyright 2024 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 os_test
+
+import (
+	. "os"
+	"path/filepath"
+	"runtime"
+	"testing"
+)
+
+func TestTruncate(t *testing.T) {
+	if runtime.GOOS == "windows" {
+		t.Skip()
+	}
+
+	tmpDir := t.TempDir()
+	file := filepath.Join(tmpDir, "truncate_test")
+
+	fd, err := Create(file)
+	if err != nil {
+		t.Fatalf("create %q: got %v, want nil", file, err)
+	}
+
+	// truncate up to 0x100
+	if err := fd.Truncate(0x100); err != nil {
+		t.Fatalf("truncate %q: got %v, want nil", file, err)
+	}
+
+	// check if size is 0x100
+	fi, err := Stat(file)
+	if err != nil {
+		t.Fatalf("stat %q: got %v, want nil", file, err)
+	}
+
+	if fi.Size() != 0x100 {
+		t.Fatalf("size of %q is %d; want 0x100", file, fi.Size())
+	}
+
+	// truncate down to 0x80
+	if err := fd.Truncate(0x80); err != nil {
+		t.Fatalf("truncate %q: got %v, want nil", file, err)
+	}
+
+	// check if size is 0x80
+	fi, err = Stat(file)
+	if err != nil {
+		t.Fatalf("stat %q: got %v, want nil", file, err)
+	}
+
+	if fi.Size() != 0x80 {
+		t.Fatalf("size of %q is %d; want 0x80", file, fi.Size())
+	}
+}

src/syscall/syscall_libc.go

@@ -153,6 +153,15 @@ func Unlink(path string) (err error) {
 	return
 }
 
+func Truncate(path string, length int64) (err error) {
+	data := cstring(path)
+	fail := int(libc_truncate(&data[0], length))
+	if fail < 0 {
+		err = getErrno()
+	}
+	return
+}
+
 func Faccessat(dirfd int, path string, mode uint32, flags int) (err error)
 
 func Kill(pid int, sig Signal) (err error) {
@@ -431,5 +440,10 @@ func libc_readlink(path *byte, buf *byte, count uint) int
 //export unlink
 func libc_unlink(pathname *byte) int32
 
+// int truncate(const char *path, off_t length);
+//
+//export truncate
+func libc_truncate(path *byte, length int64) int32
+
 //go:extern environ
 var libc_environ *unsafe.Pointer