Maison > développement back-end > Golang > le corps du texte

Comment utiliser les appels système Linux dans Go ?

WBOY
Libérer: 2023-05-11 15:18:06
original
1708 Les gens l'ont consulté

Avec le développement continu de la technologie informatique, nos exigences en matière de systèmes informatiques sont de plus en plus élevées. Dans ce processus, le rôle du système d’exploitation devient de plus en plus important. Linux est un système d'exploitation couramment utilisé et ses appels système sont devenus un élément fondamental du système Linux. En tant que langage hautes performances pour un développement rapide, le langage Go prend naturellement en charge les appels système Linux et fournit une interface de programmation sous-jacente pratique pour le système d'exploitation.

Cet article présentera comment utiliser les appels système Linux en langage Go et l'expliquera en détail avec des codes et des exemples pertinents.

1. Bases des appels système Linux

L'appel système Linux fait référence à une interface fournie dans le système d'exploitation Linux pour accéder aux fonctions du noyau système. Les appels système Linux peuvent être considérés comme un moyen permettant aux processus utilisateur d'adresser des requêtes au noyau. Ces requêtes peuvent consister à obtenir des informations spécifiques, à effectuer certaines opérations spécifiques, etc.

Sous Linux, le numéro de l'appel système est appelé numéro d'appel système. Lors de l'utilisation de l'appel système, vous devez transmettre les paramètres correspondants. Ces paramètres sont des instructions et des données envoyées par le processus utilisateur. le noyau. La valeur de retour de l'appel système est également placée dans un registre spécial et renvoyée au processus utilisateur. Les appels système sont implémentés sous Linux à l'aide d'interruptions logicielles, c'est-à-dire en appelant l'instruction int 0x80 pour réaliser la conversion du mode utilisateur au mode noyau.

2. Appels système en langage Go

La bibliothèque syscall est utilisée en langage Go pour implémenter les appels système. Cette bibliothèque encapsule tous les appels système du système Linux et fournit une interface unifiée que les programmeurs peuvent utiliser.

Les appels système couramment utilisés incluent :

  1. Ouvrir le fichier/répertoire : Ouvrir
  2. Lire le contenu du fichier/répertoire : Lire#🎜 🎜 #
  3. Écrire le contenu du fichier/répertoire : Écrire
  4. Fermer le fichier/répertoire : Fermer
  5. Supprimer le fichier/répertoire : Supprimer
  6. #🎜 🎜# Prenons comme exemple les appels système couramment utilisés mentionnés ci-dessus pour décrire comment utiliser les appels système en langage Go.

Ouvrir un fichier/répertoire
  1. Pour ouvrir un fichier/répertoire en langage Go utilisez l'appel système Ouvrir :
#🎜🎜 #func Open(path string, flag int, perm uint32) (uintptr, error)

où path représente le chemin du fichier/répertoire ouvert ; l'indicateur représente l'indicateur d'opération, tel que O_RDONLY représente le mode lecture seule , O_WRONLY représente uniquement le mode écriture, O_RDWR indique le mode lecture-écriture, O_CREATE indique la création de fichiers, etc. ; perm indique les autorisations du fichier/répertoire, comme 0777 indique que le fichier peut être lu, écrit et exécuté. La valeur de retour de la fonction Open est un descripteur de fichier de type uintptr et une erreur de type error.

Ce qui suit est un exemple de code qui montre comment ouvrir un fichier et lire le contenu du fichier en langage Go :

package main

import (
    "fmt"
    "os"
    "syscall"
)

func main() {
    filePath := "test.txt"
    fd, err := syscall.Open(filePath, syscall.O_RDONLY, 0)
    if err != nil {
        fmt.Println("Open file error:", err)
        return
    }
    defer syscall.Close(fd)

    fileInfo, err := os.Stat(filePath)
    if err != nil {
        fmt.Println("Get file info error:", err)
        return
    }

    fileSize := fileInfo.Size()
    buf := make([]byte, fileSize)

    n, err := syscall.Read(fd, buf)
    if err != nil {
        fmt.Println("Read file error:", err)
        return
    }

    fmt.Printf("Read %d bytes from file:
%s", n, string(buf))
}
Copier après la connexion

Lire le contenu du fichier/répertoire#🎜 🎜#

    Utilisez l'appel système Read pour lire le contenu du fichier/répertoire. L'exemple de code est le suivant :
  1. package main
    
    import (
        "fmt"
        "syscall"
    )
    
    func main() {
        fd, err := syscall.Open(".", syscall.O_RDONLY, 0)
        if err != nil {
            fmt.Println("Open directory error:", err)
            return
        }
        defer syscall.Close(fd)
    
        buf := make([]byte, 1024)
    
        // 循环遍历文件/目录中的内容
        for {
            n, err := syscall.Read(fd, buf)
            if err != nil {
                fmt.Println("Read directory error:", err)
                return
            }
    
            // 如果已经读取到文件/目录尾部,则退出循环
            if n == 0 {
                break
            }
    
            fmt.Printf("%d bytes:
    %s", n, string(buf[:n]))
        }
    }
    Copier après la connexion
Écrivez le fichier/répertoire. content#🎜🎜 #

Utilisez l'appel système Write pour écrire du contenu dans un fichier/répertoire L'exemple de code est le suivant :
    package main
    
    import (
        "fmt"
        "syscall"
    )
    
    func main() {
        filePath := "test.txt"
        fd, err := syscall.Open(filePath, syscall.O_RDWR|syscall.O_APPEND, 0)
        if err != nil {
            fmt.Println("Open file error:", err)
            return
        }
        defer syscall.Close(fd)
    
        content := "Hello, World!
    "
        n, err := syscall.Write(fd, []byte(content))
        if err != nil {
            fmt.Println("Write file error:", err)
            return
        }
    
        fmt.Printf("Write %d bytes to file.
    ", n)
    }
    Copier après la connexion
  1. Fermez le fichier. /directory
#🎜 🎜#

Utilisez l'appel système Close pour fermer un fichier/répertoire ouvert. L'exemple de code est le suivant :

package main

import (
    "fmt"
    "syscall"
)

func main() {
    fd, err := syscall.Open(".", syscall.O_RDONLY, 0)
    if err != nil {
        fmt.Println("Open directory error:", err)
        return
    }

    // 进行相关的操作

    syscall.Close(fd)
}
Copier après la connexion
  1. Delete file/. directory
# 🎜🎜#Utilisez l'appel système Remove pour supprimer des fichiers/répertoires. L'exemple de code est le suivant :

package main

import (
    "fmt"
    "syscall"
)

func main() {
    filePath := "test.txt"
    err := syscall.Remove(filePath)
    if err != nil {
        fmt.Println("Remove file error:", err)
        return
    }

    fmt.Println("Remove file success.")
}
Copier après la connexion

3. #Cet article explique principalement comment utiliser les appels système Linux en langage Go . Nous avons présenté les connaissances de base des appels système, combinées aux appels système couramment utilisés (Ouvrir, Lire, Écrire, Fermer, Supprimer) pour expliquer en détail, et avons donné des exemples de codes pertinents.
  1. Grâce à l'étude de cet article, je pense que vous maîtrisez les méthodes de base d'utilisation des appels système dans le langage Go. J'espère qu'il vous sera utile.

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!

Étiquettes associées:
source:php.cn
Déclaration de ce site Web
Le contenu de cet article est volontairement contribué par les internautes et les droits d'auteur appartiennent à l'auteur original. Ce site n'assume aucune responsabilité légale correspondante. Si vous trouvez un contenu suspecté de plagiat ou de contrefaçon, veuillez contacter admin@php.cn
Tutoriels populaires
Plus>
Derniers téléchargements
Plus>
effets Web
Code source du site Web
Matériel du site Web
Modèle frontal