File Manager

X7ROOT File Manager

Current Path: /opt/golang/1.22.0/src/os

📁 ..
📄 dir.go(4.4 KB)
📄 dir_darwin.go(3.34 KB)
📄 dir_plan9.go(2.1 KB)
📄 dir_unix.go(5.24 KB)
📄 dir_windows.go(7.17 KB)
📄 dirent_aix.go(759 B)
📄 dirent_dragonfly.go(1.28 KB)
📄 dirent_freebsd.go(1.16 KB)
📄 dirent_js.go(678 B)
📄 dirent_linux.go(1.18 KB)
📄 dirent_netbsd.go(1.16 KB)
📄 dirent_openbsd.go(1.16 KB)
📄 dirent_solaris.go(759 B)
📄 dirent_wasip1.go(1.36 KB)
📄 endian_big.go(244 B)
📄 endian_little.go(304 B)
📄 env.go(3.85 KB)
📄 env_test.go(5.04 KB)
📄 env_unix_test.go(1.22 KB)
📄 error.go(4.76 KB)
📄 error_errno.go(247 B)
📄 error_plan9.go(234 B)
📄 error_posix.go(538 B)
📄 error_test.go(4.92 KB)
📄 error_unix_test.go(1.49 KB)
📄 error_windows_test.go(1.72 KB)
📄 example_test.go(8.39 KB)
📁 exec
📄 exec.go(6.01 KB)
📄 exec_plan9.go(3.27 KB)
📄 exec_posix.go(3.44 KB)
📄 exec_unix.go(2.09 KB)
📄 exec_unix_test.go(999 B)
📄 exec_windows.go(4.57 KB)
📄 exec_windows_test.go(1.78 KB)
📄 executable.go(774 B)
📄 executable_darwin.go(613 B)
📄 executable_dragonfly.go(293 B)
📄 executable_freebsd.go(292 B)
📄 executable_path.go(2.31 KB)
📄 executable_plan9.go(427 B)
📄 executable_procfs.go(904 B)
📄 executable_solaris.go(695 B)
📄 executable_sysctl.go(891 B)
📄 executable_test.go(3.4 KB)
📄 executable_wasm.go(333 B)
📄 executable_windows.go(641 B)
📄 export_linux_test.go(337 B)
📄 export_test.go(433 B)
📄 export_unix_test.go(241 B)
📄 export_windows_test.go(395 B)
📄 fifo_test.go(4.62 KB)
📄 file.go(24.91 KB)
📄 file_mutex_plan9.go(1.81 KB)
📄 file_open_unix.go(397 B)
📄 file_open_wasip1.go(818 B)
📄 file_plan9.go(15.99 KB)
📄 file_posix.go(7.1 KB)
📄 file_unix.go(14.05 KB)
📄 file_wasip1.go(633 B)
📄 file_windows.go(12.65 KB)
📄 getwd.go(2.52 KB)
📄 os_test.go(77.07 KB)
📄 os_unix_test.go(11.47 KB)
📄 os_windows_test.go(41.83 KB)
📄 path.go(2.27 KB)
📄 path_plan9.go(492 B)
📄 path_test.go(2.96 KB)
📄 path_unix.go(1.56 KB)
📄 path_windows.go(5.66 KB)
📄 path_windows_test.go(4.03 KB)
📄 pipe2_unix.go(640 B)
📄 pipe_test.go(12.41 KB)
📄 pipe_unix.go(760 B)
📄 pipe_wasm.go(488 B)
📄 proc.go(2.27 KB)
📄 rawconn.go(993 B)
📄 rawconn_test.go(1.15 KB)
📄 read_test.go(3.2 KB)
📄 readfrom_linux_test.go(20.3 KB)
📄 removeall_at.go(4.91 KB)
📄 removeall_noat.go(3.13 KB)
📄 removeall_test.go(11.96 KB)
📁 signal
📄 stat.go(965 B)
📄 stat_aix.go(1.18 KB)
📄 stat_darwin.go(1.09 KB)
📄 stat_dragonfly.go(1.06 KB)
📄 stat_freebsd.go(1.07 KB)
📄 stat_js.go(1.11 KB)
📄 stat_linux.go(1.06 KB)
📄 stat_netbsd.go(1.07 KB)
📄 stat_openbsd.go(1.06 KB)
📄 stat_plan9.go(2.37 KB)
📄 stat_solaris.go(1.3 KB)
📄 stat_test.go(6.46 KB)
📄 stat_unix.go(1.23 KB)
📄 stat_wasip1.go(956 B)
📄 stat_windows.go(4.93 KB)
📄 sticky_bsd.go(425 B)
📄 sticky_notbsd.go(320 B)
📄 sys.go(294 B)
📄 sys_aix.go(682 B)
📄 sys_bsd.go(466 B)
📄 sys_js.go(313 B)
📄 sys_linux.go(1.04 KB)
📄 sys_plan9.go(453 B)
📄 sys_solaris.go(265 B)
📄 sys_unix.go(493 B)
📄 sys_wasip1.go(309 B)
📄 sys_windows.go(874 B)
📄 tempfile.go(3.8 KB)
📄 tempfile_test.go(5.49 KB)
📁 testdata
📄 timeout_test.go(17.09 KB)
📄 types.go(2.79 KB)
📄 types_plan9.go(797 B)
📄 types_unix.go(776 B)
📄 types_windows.go(10.01 KB)
📁 user
📄 wait6_dragonfly.go(496 B)
📄 wait6_freebsd64.go(547 B)
📄 wait6_freebsd_386.go(544 B)
📄 wait6_freebsd_arm.go(549 B)
📄 wait6_netbsd.go(534 B)
📄 wait_unimp.go(831 B)
📄 wait_wait6.go(781 B)
📄 wait_waitid.go(1.32 KB)
📄 writeto_linux_test.go(4.21 KB)
📄 zero_copy_linux.go(4.38 KB)
📄 zero_copy_stub.go(406 B)

Editing: exec.go

// Copyright 2009 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

import (
	"errors"
	"internal/testlog"
	"runtime"
	"sync"
	"sync/atomic"
	"syscall"
	"time"
)

// ErrProcessDone indicates a Process has finished.
var ErrProcessDone = errors.New("os: process already finished")

// Process stores the information about a process created by StartProcess.
type Process struct {
	Pid    int
	handle uintptr      // handle is accessed atomically on Windows
	isdone atomic.Bool  // process has been successfully waited on
	sigMu  sync.RWMutex // avoid race between wait and signal
}

func newProcess(pid int, handle uintptr) *Process {
	p := &Process{Pid: pid, handle: handle}
	runtime.SetFinalizer(p, (*Process).Release)
	return p
}

func (p *Process) setDone() {
	p.isdone.Store(true)
}

func (p *Process) done() bool {
	return p.isdone.Load()
}

// ProcAttr holds the attributes that will be applied to a new process
// started by StartProcess.
type ProcAttr struct {
	// If Dir is non-empty, the child changes into the directory before
	// creating the process.
	Dir string
	// If Env is non-nil, it gives the environment variables for the
	// new process in the form returned by Environ.
	// If it is nil, the result of Environ will be used.
	Env []string
	// Files specifies the open files inherited by the new process. The
	// first three entries correspond to standard input, standard output, and
	// standard error. An implementation may support additional entries,
	// depending on the underlying operating system. A nil entry corresponds
	// to that file being closed when the process starts.
	// On Unix systems, StartProcess will change these File values
	// to blocking mode, which means that SetDeadline will stop working
	// and calling Close will not interrupt a Read or Write.
	Files []*File

// Operating system-specific process creation attributes.
	// Note that setting this field means that your program
	// may not execute properly or even compile on some
	// operating systems.
	Sys *syscall.SysProcAttr
}

// A Signal represents an operating system signal.
// The usual underlying implementation is operating system-dependent:
// on Unix it is syscall.Signal.
type Signal interface {
	String() string
	Signal() // to distinguish from other Stringers
}

// Getpid returns the process id of the caller.
func Getpid() int { return syscall.Getpid() }

// Getppid returns the process id of the caller's parent.
func Getppid() int { return syscall.Getppid() }

// FindProcess looks for a running process by its pid.
//
// The Process it returns can be used to obtain information
// about the underlying operating system process.
//
// On Unix systems, FindProcess always succeeds and returns a Process
// for the given pid, regardless of whether the process exists. To test whether
// the process actually exists, see whether p.Signal(syscall.Signal(0)) reports
// an error.
func FindProcess(pid int) (*Process, error) {
	return findProcess(pid)
}

// StartProcess starts a new process with the program, arguments and attributes
// specified by name, argv and attr. The argv slice will become os.Args in the
// new process, so it normally starts with the program name.
//
// If the calling goroutine has locked the operating system thread
// with runtime.LockOSThread and modified any inheritable OS-level
// thread state (for example, Linux or Plan 9 name spaces), the new
// process will inherit the caller's thread state.
//
// StartProcess is a low-level interface. The os/exec package provides
// higher-level interfaces.
//
// If there is an error, it will be of type *PathError.
func StartProcess(name string, argv []string, attr *ProcAttr) (*Process, error) {
	testlog.Open(name)
	return startProcess(name, argv, attr)
}

// Release releases any resources associated with the Process p,
// rendering it unusable in the future.
// Release only needs to be called if Wait is not.
func (p *Process) Release() error {
	return p.release()
}

// Kill causes the Process to exit immediately. Kill does not wait until
// the Process has actually exited. This only kills the Process itself,
// not any other processes it may have started.
func (p *Process) Kill() error {
	return p.kill()
}

// Wait waits for the Process to exit, and then returns a
// ProcessState describing its status and an error, if any.
// Wait releases any resources associated with the Process.
// On most operating systems, the Process must be a child
// of the current process or an error will be returned.
func (p *Process) Wait() (*ProcessState, error) {
	return p.wait()
}

// Signal sends a signal to the Process.
// Sending Interrupt on Windows is not implemented.
func (p *Process) Signal(sig Signal) error {
	return p.signal(sig)
}

// UserTime returns the user CPU time of the exited process and its children.
func (p *ProcessState) UserTime() time.Duration {
	return p.userTime()
}

// SystemTime returns the system CPU time of the exited process and its children.
func (p *ProcessState) SystemTime() time.Duration {
	return p.systemTime()
}

// Exited reports whether the program has exited.
// On Unix systems this reports true if the program exited due to calling exit,
// but false if the program terminated due to a signal.
func (p *ProcessState) Exited() bool {
	return p.exited()
}

// Success reports whether the program exited successfully,
// such as with exit status 0 on Unix.
func (p *ProcessState) Success() bool {
	return p.success()
}

// Sys returns system-dependent exit information about
// the process. Convert it to the appropriate underlying
// type, such as syscall.WaitStatus on Unix, to access its contents.
func (p *ProcessState) Sys() any {
	return p.sys()
}

// SysUsage returns system-dependent resource usage information about
// the exited process. Convert it to the appropriate underlying
// type, such as *syscall.Rusage on Unix, to access its contents.
// (On Unix, *syscall.Rusage matches struct rusage as defined in the
// getrusage(2) manual page.)
func (p *ProcessState) SysUsage() any {
	return p.sysUsage()
}

X7ROOT File Manager

Editing: exec.go

Upload File

Create Folder