func (s *DependenciesStub) writeAllToDryRunPath() error {
	path := DryRunFilePath.Get()
	if path != "" {
		// Print the input into the given output file.
		f, err := os.OpenFile(path, os.O_CREATE|os.O_WRONLY, 0o644)
		if err != nil {
			return fmt.Errorf("unable to open dry run output file %v: %v", path, err)
		}

		defer f.Close()

		for _, line := range s.ExecutedAll {
			_, err := f.WriteString(line + "\n")

	b := byte(0)
	write(uintptr(waitForSigusr1.wrpipe), noescape(unsafe.Pointer(&b)), 1)
	return true
}

// SendSigusr1 sends SIGUSR1 to mp.
func SendSigusr1(mp *M) {
	signalM(mp, _SIGUSR1)
}

const (
	O_WRONLY = _O_WRONLY
	O_CREAT  = _O_CREAT
	O_TRUNC  = _O_TRUNC

	}

	return newPIDProcess(pid), nil
}

func (p *Process) writeProcFile(file string, data string) error {
	f, e := OpenFile("/proc/"+itoa.Itoa(p.Pid)+"/"+file, O_WRONLY, 0)
	if e != nil {
		return e
	}
	defer f.Close()
	_, e = f.Write([]byte(data))
	return e
}

func (p *Process) signal(sig Signal) error {
	switch p.pidStatus() {
	case statusDone:

func (mu *Mutex) Lock() (unlock func(), err error) {
	if mu.Path == "" {
		panic("lockedfile.Mutex: missing Path during Lock")
	}

	// We could use either O_RDWR or O_WRONLY here. If we choose O_RDWR and the
	// file at mu.Path is write-only, the call to OpenFile will fail with a
	// permission error. That's actually what we want: if we add an RLock method

    public SmbFileOutputStream( SmbFile file, boolean append ) throws SmbException, MalformedURLException, UnknownHostException {
        this( file, append, append ? SmbFile.O_CREAT | SmbFile.O_WRONLY | SmbFile.O_APPEND :
                                    SmbFile.O_CREAT | SmbFile.O_WRONLY | SmbFile.O_TRUNC );
    }
/**
 * Creates an {@link java.io.OutputStream} for writing bytes to a file
 * on an SMB server addressed by the <code>SmbFile</code> parameter. See

		if err != nil {
			panic(err)
		}

		pruneXML(suites, *maxTextSize*1e6) // convert MB into bytes (roughly!)
		if *pruneTests {
			pruneTESTS(suites)
		}

		xmlWriter, err := os.OpenFile(path, os.O_WRONLY|os.O_CREATE|os.O_TRUNC, 0666)
		if err != nil {
			panic(err)
		}
		defer xmlWriter.Close()
		err = streamXML(xmlWriter, suites)
		if err != nil {
			panic(err)
		}
		fmt.Println("done.")
	}
}

		case <-time.After(100 * time.Millisecond):
			// nothing to read - good
		}
	}
}

func postNote(pid int, note string) error {
	f, err := os.OpenFile("/proc/"+itoa.Itoa(pid)+"/note", os.O_WRONLY, 0)
	if err != nil {
		return err
	}
	defer f.Close()
	_, err = f.Write([]byte(note))
	return err

	if err != nil {
		return err
	}
	defer in.Close()

	perm, err := in.Stat()
	if err != nil {
		return err
	}

	out, err := os.OpenFile(filepath.Join(targetDir, targetFilename), os.O_WRONLY|os.O_CREATE|os.O_TRUNC, perm.Mode())
	if err != nil {
		return err
	}
	defer out.Close()

	if _, err := io.Copy(out, in); err != nil {
		return err
	}
	return nil
}

        this(
            file,
            append,
            append ? SmbConstants.O_CREAT | SmbConstants.O_WRONLY | SmbConstants.O_APPEND
                    : SmbConstants.O_CREAT | SmbConstants.O_WRONLY | SmbConstants.O_TRUNC,
            0,
            SmbConstants.DEFAULT_SHARING);
    }

			clear(dst)
			writePos = 0
		}
	}
}

func initLegacy() {
	// In legacy mode, logs are written to /dev/log/main
	writeFD = uintptr(open(&writePath[0], 0x1 /* O_WRONLY */, 0))
	if writeFD == 0 {
		// It is hard to do anything here. Write to stderr just
		// in case user has root on device and has run
		//	adb shell setprop log.redirect-stdio true