src/syscall/syscall_plan9.go

   1 // Copyright 2011 The Go Authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style
   3 // license that can be found in the LICENSE file.
   4
   5 // Plan 9 system calls.
   6 // This file is compiled as ordinary Go code,
   7 // but it is also input to mksyscall,
   8 // which parses the //sys lines and generates system call stubs.
   9 // Note that sometimes we use a lowercase //sys name and
  10 // wrap it in our own nicer implementation.
  11
  12 package syscall
  13
  14 import (
  15         "errors"
  16         "internal/oserror"
  17         "runtime"
  18         "unsafe"
  19 )
  20
  21 const ImplementsGetwd = true
  22 const bitSize16 = 2
  23
  24 // ErrorString implements Error's String method by returning itself.
  25 //
  26 // ErrorString values can be tested against error values using errors.Is.
  27 // For example:
  28 //
  29 //      _, _, err := syscall.Syscall(...)
  30 //      if errors.Is(err, fs.ErrNotExist) ...
  31 type ErrorString string
  32
  33 func (e ErrorString) Error() string { return string(e) }
  34
  35 // NewError converts s to an ErrorString, which satisfies the Error interface.
  36 func NewError(s string) error { return ErrorString(s) }
  37
  38 func (e ErrorString) Is(target error) bool {
  39         switch target {
  40         case oserror.ErrPermission:
  41                 return checkErrMessageContent(e, "permission denied")
  42         case oserror.ErrExist:
  43                 return checkErrMessageContent(e, "exists", "is a directory")
  44         case oserror.ErrNotExist:
  45                 return checkErrMessageContent(e, "does not exist", "not found",
  46                         "has been removed", "no parent")
  47         case errors.ErrUnsupported:
  48                 return checkErrMessageContent(e, "not supported")
  49         }
  50         return false
  51 }
  52
  53 // checkErrMessageContent checks if err message contains one of msgs.
  54 func checkErrMessageContent(e ErrorString, msgs ...string) bool {
  55         for _, msg := range msgs {
  56                 if contains(string(e), msg) {
  57                         return true
  58                 }
  59         }
  60         return false
  61 }
  62
  63 // contains is a local version of strings.Contains. It knows len(sep) > 1.
  64 func contains(s, sep string) bool {
  65         n := len(sep)
  66         c := sep[0]
  67         for i := 0; i+n <= len(s); i++ {
  68                 if s[i] == c && s[i:i+n] == sep {
  69                         return true
  70                 }
  71         }
  72         return false
  73 }
  74
  75 func (e ErrorString) Temporary() bool {
  76         return e == EINTR || e == EMFILE || e.Timeout()
  77 }
  78
  79 func (e ErrorString) Timeout() bool {
  80         return e == EBUSY || e == ETIMEDOUT
  81 }
  82
  83 var emptystring string
  84
  85 // A Note is a string describing a process note.
  86 // It implements the os.Signal interface.
  87 type Note string
  88
  89 func (n Note) Signal() {}
  90
  91 func (n Note) String() string {
  92         return string(n)
  93 }
  94
  95 var (
  96         Stdin  = 0
  97         Stdout = 1
  98         Stderr = 2
  99 )
 100
 101 // For testing: clients can set this flag to force
 102 // creation of IPv6 sockets to return EAFNOSUPPORT.
 103 var SocketDisableIPv6 bool
 104
 105 func Syscall(trap, a1, a2, a3 uintptr) (r1, r2 uintptr, err ErrorString)
 106 func Syscall6(trap, a1, a2, a3, a4, a5, a6 uintptr) (r1, r2 uintptr, err ErrorString)
 107 func RawSyscall(trap, a1, a2, a3 uintptr) (r1, r2, err uintptr)
 108 func RawSyscall6(trap, a1, a2, a3, a4, a5, a6 uintptr) (r1, r2, err uintptr)
 109
 110 //go:nosplit
 111 func atoi(b []byte) (n uint) {
 112         n = 0
 113         for i := 0; i < len(b); i++ {
 114                 n = n*10 + uint(b[i]-'0')
 115         }
 116         return
 117 }
 118
 119 func cstring(s []byte) string {
 120         for i := range s {
 121                 if s[i] == 0 {
 122                         return string(s[0:i])
 123                 }
 124         }
 125         return string(s)
 126 }
 127
 128 func errstr() string {
 129         var buf [ERRMAX]byte
 130
 131         RawSyscall(SYS_ERRSTR, uintptr(unsafe.Pointer(&buf[0])), uintptr(len(buf)), 0)
 132
 133         buf[len(buf)-1] = 0
 134         return cstring(buf[:])
 135 }
 136
 137 func readnum(path string) (uint, error) {
 138         var b [12]byte
 139
 140         fd, e := Open(path, O_RDONLY)
 141         if e != nil {
 142                 return 0, e
 143         }
 144         defer Close(fd)
 145
 146         n, e := Pread(fd, b[:], 0)
 147
 148         if e != nil {
 149                 return 0, e
 150         }
 151
 152         m := 0
 153         for ; m < n && b[m] == ' '; m++ {
 154         }
 155
 156         return atoi(b[m : n-1]), nil
 157 }
 158
 159 func Getpid() (pid int) {
 160         n, _ := readnum("#c/pid")
 161         return int(n)
 162 }
 163
 164 func Getppid() (ppid int) {
 165         n, _ := readnum("#c/ppid")
 166         return int(n)
 167 }
 168
 169 func Read(fd int, p []byte) (n int, err error) {
 170         return Pread(fd, p, -1)
 171 }
 172
 173 func Write(fd int, p []byte) (n int, err error) {
 174         if faketime && (fd == 1 || fd == 2) {
 175                 n = faketimeWrite(fd, p)
 176                 if n < 0 {
 177                         return 0, ErrorString("error")
 178                 }
 179                 return n, nil
 180         }
 181
 182         return Pwrite(fd, p, -1)
 183 }
 184
 185 var ioSync int64
 186
 187 //sys   fd2path(fd int, buf []byte) (err error)
 188
 189 func Fd2path(fd int) (path string, err error) {
 190         var buf [512]byte
 191
 192         e := fd2path(fd, buf[:])
 193         if e != nil {
 194                 return "", e
 195         }
 196         return cstring(buf[:]), nil
 197 }
 198
 199 //sys   pipe(p *[2]int32) (err error)
 200
 201 func Pipe(p []int) (err error) {
 202         if len(p) != 2 {
 203                 return NewError("bad arg in system call")
 204         }
 205         var pp [2]int32
 206         err = pipe(&pp)
 207         if err == nil {
 208                 p[0] = int(pp[0])
 209                 p[1] = int(pp[1])
 210         }
 211         return
 212 }
 213
 214 // Underlying system call writes to newoffset via pointer.
 215 // Implemented in assembly to avoid allocation.
 216 func seek(placeholder uintptr, fd int, offset int64, whence int) (newoffset int64, err string)
 217
 218 func Seek(fd int, offset int64, whence int) (newoffset int64, err error) {
 219         newoffset, e := seek(0, fd, offset, whence)
 220
 221         if newoffset == -1 {
 222                 err = NewError(e)
 223         }
 224         return
 225 }
 226
 227 func Mkdir(path string, mode uint32) (err error) {
 228         // If path exists and is not a directory, Create will fail silently.
 229         // Work around this by rejecting Mkdir if path exists.
 230         statbuf := make([]byte, bitSize16)
 231         // Remove any trailing slashes from path, otherwise the Stat will
 232         // fail with ENOTDIR.
 233         n := len(path)
 234         for n > 1 && path[n-1] == '/' {
 235                 n--
 236         }
 237         _, err = Stat(path[0:n], statbuf)
 238         if err == nil {
 239                 return EEXIST
 240         }
 241
 242         fd, err := Create(path, O_RDONLY, DMDIR|mode)
 243
 244         if fd != -1 {
 245                 Close(fd)
 246         }
 247
 248         return
 249 }
 250
 251 type Waitmsg struct {
 252         Pid  int
 253         Time [3]uint32
 254         Msg  string
 255 }
 256
 257 func (w Waitmsg) Exited() bool   { return true }
 258 func (w Waitmsg) Signaled() bool { return false }
 259
 260 func (w Waitmsg) ExitStatus() int {
 261         if len(w.Msg) == 0 {
 262                 // a normal exit returns no message
 263                 return 0
 264         }
 265         return 1
 266 }
 267
 268 //sys   await(s []byte) (n int, err error)
 269
 270 func Await(w *Waitmsg) (err error) {
 271         var buf [512]byte
 272         var f [5][]byte
 273
 274         n, err := await(buf[:])
 275
 276         if err != nil || w == nil {
 277                 return
 278         }
 279
 280         nf := 0
 281         p := 0
 282         for i := 0; i < n && nf < len(f)-1; i++ {
 283                 if buf[i] == ' ' {
 284                         f[nf] = buf[p:i]
 285                         p = i + 1
 286                         nf++
 287                 }
 288         }
 289         f[nf] = buf[p:]
 290         nf++
 291
 292         if nf != len(f) {
 293                 return NewError("invalid wait message")
 294         }
 295         w.Pid = int(atoi(f[0]))
 296         w.Time[0] = uint32(atoi(f[1]))
 297         w.Time[1] = uint32(atoi(f[2]))
 298         w.Time[2] = uint32(atoi(f[3]))
 299         w.Msg = cstring(f[4])
 300         if w.Msg == "''" {
 301                 // await() returns '' for no error
 302                 w.Msg = ""
 303         }
 304         return
 305 }
 306
 307 func Unmount(name, old string) (err error) {
 308         if fixwd(name, old) {
 309                 defer runtime.UnlockOSThread()
 310         }
 311         oldp, err := BytePtrFromString(old)
 312         if err != nil {
 313                 return err
 314         }
 315         oldptr := uintptr(unsafe.Pointer(oldp))
 316
 317         var r0 uintptr
 318         var e ErrorString
 319
 320         // bind(2) man page: If name is zero, everything bound or mounted upon old is unbound or unmounted.
 321         if name == "" {
 322                 r0, _, e = Syscall(SYS_UNMOUNT, _zero, oldptr, 0)
 323         } else {
 324                 namep, err := BytePtrFromString(name)
 325                 if err != nil {
 326                         return err
 327                 }
 328                 r0, _, e = Syscall(SYS_UNMOUNT, uintptr(unsafe.Pointer(namep)), oldptr, 0)
 329         }
 330
 331         if int32(r0) == -1 {
 332                 err = e
 333         }
 334         return
 335 }
 336
 337 func Fchdir(fd int) (err error) {
 338         path, err := Fd2path(fd)
 339
 340         if err != nil {
 341                 return
 342         }
 343
 344         return Chdir(path)
 345 }
 346
 347 type Timespec struct {
 348         Sec  int32
 349         Nsec int32
 350 }
 351
 352 type Timeval struct {
 353         Sec  int32
 354         Usec int32
 355 }
 356
 357 func NsecToTimeval(nsec int64) (tv Timeval) {
 358         nsec += 999 // round up to microsecond
 359         tv.Usec = int32(nsec % 1e9 / 1e3)
 360         tv.Sec = int32(nsec / 1e9)
 361         return
 362 }
 363
 364 func nsec() int64 {
 365         var scratch int64
 366
 367         r0, _, _ := Syscall(SYS_NSEC, uintptr(unsafe.Pointer(&scratch)), 0, 0)
 368         // TODO(aram): remove hack after I fix _nsec in the pc64 kernel.
 369         if r0 == 0 {
 370                 return scratch
 371         }
 372         return int64(r0)
 373 }
 374
 375 func Gettimeofday(tv *Timeval) error {
 376         nsec := nsec()
 377         *tv = NsecToTimeval(nsec)
 378         return nil
 379 }
 380
 381 func Getegid() (egid int) { return -1 }
 382 func Geteuid() (euid int) { return -1 }
 383 func Getgid() (gid int)   { return -1 }
 384 func Getuid() (uid int)   { return -1 }
 385
 386 func Getgroups() (gids []int, err error) {
 387         return make([]int, 0), nil
 388 }
 389
 390 //sys   open(path string, mode int) (fd int, err error)
 391
 392 func Open(path string, mode int) (fd int, err error) {
 393         if fixwd(path) {
 394                 defer runtime.UnlockOSThread()
 395         }
 396         return open(path, mode)
 397 }
 398
 399 //sys   create(path string, mode int, perm uint32) (fd int, err error)
 400
 401 func Create(path string, mode int, perm uint32) (fd int, err error) {
 402         if fixwd(path) {
 403                 defer runtime.UnlockOSThread()
 404         }
 405         return create(path, mode, perm)
 406 }
 407
 408 //sys   remove(path string) (err error)
 409
 410 func Remove(path string) error {
 411         if fixwd(path) {
 412                 defer runtime.UnlockOSThread()
 413         }
 414         return remove(path)
 415 }
 416
 417 //sys   stat(path string, edir []byte) (n int, err error)
 418
 419 func Stat(path string, edir []byte) (n int, err error) {
 420         if fixwd(path) {
 421                 defer runtime.UnlockOSThread()
 422         }
 423         return stat(path, edir)
 424 }
 425
 426 //sys   bind(name string, old string, flag int) (err error)
 427
 428 func Bind(name string, old string, flag int) (err error) {
 429         if fixwd(name, old) {
 430                 defer runtime.UnlockOSThread()
 431         }
 432         return bind(name, old, flag)
 433 }
 434
 435 //sys   mount(fd int, afd int, old string, flag int, aname string) (err error)
 436
 437 func Mount(fd int, afd int, old string, flag int, aname string) (err error) {
 438         if fixwd(old) {
 439                 defer runtime.UnlockOSThread()
 440         }
 441         return mount(fd, afd, old, flag, aname)
 442 }
 443
 444 //sys   wstat(path string, edir []byte) (err error)
 445
 446 func Wstat(path string, edir []byte) (err error) {
 447         if fixwd(path) {
 448                 defer runtime.UnlockOSThread()
 449         }
 450         return wstat(path, edir)
 451 }
 452
 453 //sys   chdir(path string) (err error)
 454 //sys   Dup(oldfd int, newfd int) (fd int, err error)
 455 //sys   Pread(fd int, p []byte, offset int64) (n int, err error)
 456 //sys   Pwrite(fd int, p []byte, offset int64) (n int, err error)
 457 //sys   Close(fd int) (err error)
 458 //sys   Fstat(fd int, edir []byte) (n int, err error)
 459 //sys   Fwstat(fd int, edir []byte) (err error)