restic/internal/fs/node_linux.go

package fs

import (
	"github.com/restic/restic/internal/restic"
	"golang.org/x/sys/unix"
)

// utimesNano is like syscall.UtimesNano, except that it does not follow symlinks.
func utimesNano(path string, atime, mtime int64, _ restic.NodeType) error {
	times := []unix.Timespec{
		unix.NsecToTimespec(atime),
		unix.NsecToTimespec(mtime),
	}
	return unix.UtimesNanoAt(unix.AT_FDCWD, path, times, unix.AT_SYMLINK_NOFOLLOW)
}
restic: extract Node filesystem code to fs package 2024-08-26 23:03:25 +02:00			`package fs`
Move platform specific code to different files 2015-02-03 21:18:19 +01:00
			`import (`
fs: Refactor UtimesNano replacements Previously, nodeRestoreTimestamps would do something like if node.Type == restic.NodeTypeSymlink { return nodeRestoreSymlinkTimestamps(...) } return syscall.UtimesNano(...) where nodeRestoreSymlinkTimestamps was either a no-op or a reimplementation of syscall.UtimesNano that handles symlinks, with some repeated converting between timestamp types. The Linux implementation was a bit clumsy, requiring three syscalls to set the timestamps. In this new setup, there is a function utimesNano that has three implementations: * on Linux, it's a modified syscall.UtimesNano that uses AT_SYMLINK_NOFOLLOW and AT_FDCWD so it can handle any type in a single call; * on other Unix platforms, it just calls the syscall function after skipping symlinks; * on Windows, it's the modified UtimesNano that was previously called nodeRestoreSymlinkTimestamps, except with different arguments. 2024-10-04 10:06:18 +02:00			`"github.com/restic/restic/internal/restic"`
fs: Use AT_FDCWD in Linux nodeRestoreSymlinkTimestamps There's no need to open the containing directory. This is exactly what syscall.UtimesNano does, except for the AT_SYMLINK_NOFOLLOW flag. 2024-10-04 11:06:26 +02:00			`"golang.org/x/sys/unix"`
Move platform specific code to different files 2015-02-03 21:18:19 +01:00			`)`

fs: Refactor UtimesNano replacements Previously, nodeRestoreTimestamps would do something like if node.Type == restic.NodeTypeSymlink { return nodeRestoreSymlinkTimestamps(...) } return syscall.UtimesNano(...) where nodeRestoreSymlinkTimestamps was either a no-op or a reimplementation of syscall.UtimesNano that handles symlinks, with some repeated converting between timestamp types. The Linux implementation was a bit clumsy, requiring three syscalls to set the timestamps. In this new setup, there is a function utimesNano that has three implementations: * on Linux, it's a modified syscall.UtimesNano that uses AT_SYMLINK_NOFOLLOW and AT_FDCWD so it can handle any type in a single call; * on other Unix platforms, it just calls the syscall function after skipping symlinks; * on Windows, it's the modified UtimesNano that was previously called nodeRestoreSymlinkTimestamps, except with different arguments. 2024-10-04 10:06:18 +02:00			`// utimesNano is like syscall.UtimesNano, except that it does not follow symlinks.`
			`func utimesNano(path string, atime, mtime int64, _ restic.NodeType) error {`
Replace lowlevel syscall to restore symlink times 2016-08-30 21:44:10 +02:00			`times := []unix.Timespec{`
fs: Refactor UtimesNano replacements Previously, nodeRestoreTimestamps would do something like if node.Type == restic.NodeTypeSymlink { return nodeRestoreSymlinkTimestamps(...) } return syscall.UtimesNano(...) where nodeRestoreSymlinkTimestamps was either a no-op or a reimplementation of syscall.UtimesNano that handles symlinks, with some repeated converting between timestamp types. The Linux implementation was a bit clumsy, requiring three syscalls to set the timestamps. In this new setup, there is a function utimesNano that has three implementations: * on Linux, it's a modified syscall.UtimesNano that uses AT_SYMLINK_NOFOLLOW and AT_FDCWD so it can handle any type in a single call; * on other Unix platforms, it just calls the syscall function after skipping symlinks; * on Windows, it's the modified UtimesNano that was previously called nodeRestoreSymlinkTimestamps, except with different arguments. 2024-10-04 10:06:18 +02:00			`unix.NsecToTimespec(atime),`
			`unix.NsecToTimespec(mtime),`
Move error annotation for symlink timestamp restore 2015-05-16 13:25:10 +02:00			`}`
fs: Refactor UtimesNano replacements Previously, nodeRestoreTimestamps would do something like if node.Type == restic.NodeTypeSymlink { return nodeRestoreSymlinkTimestamps(...) } return syscall.UtimesNano(...) where nodeRestoreSymlinkTimestamps was either a no-op or a reimplementation of syscall.UtimesNano that handles symlinks, with some repeated converting between timestamp types. The Linux implementation was a bit clumsy, requiring three syscalls to set the timestamps. In this new setup, there is a function utimesNano that has three implementations: * on Linux, it's a modified syscall.UtimesNano that uses AT_SYMLINK_NOFOLLOW and AT_FDCWD so it can handle any type in a single call; * on other Unix platforms, it just calls the syscall function after skipping symlinks; * on Windows, it's the modified UtimesNano that was previously called nodeRestoreSymlinkTimestamps, except with different arguments. 2024-10-04 10:06:18 +02:00			`return unix.UtimesNanoAt(unix.AT_FDCWD, path, times, unix.AT_SYMLINK_NOFOLLOW)`
node/Linux: Implement setting timestamps for symlinks 2015-05-14 23:06:11 +02:00			`}`