【C言語】ループの途中でSegmentation faultが出る

Question

状況と質問

Cで書かれたあるソースコード（念のため一番下に載せておきます）をコピペして動かしたいのですが、セグフォのエラーが出てしまいました。そこで最低限のものを書いて実験したところ、ループの途中でセグフォが出ていることがわかりました。

どうしてループの途中で、しかも決まった回数のときにsegmentation faultになるのでしょうか？　またそれを解決する方法はありますか？

初歩的な質問かもしれないことは承知ですが、調べるとっかかりになるワードだけでも構いませんので、ご回答いただければ助かります。

コード

// test2.h

#include <stdio.h>

struct udmabuf{
    char name[128];
    unsigned char * buf;
};

// test1.c

#include <stdio.h>
#include "test2.h"

int main(){
    struct udmabuf intake_buf;
    float a[32 * 32]; 
    int i, j; // 行列の添字
    int m, n; // 行列のサイズ
    m = n = 32;
    for (i = 0; i < m*n; i++){ // 行列を初期化
        a[i] = i / 2.0; 
    }

    int count = 0;
    for (i = 0; i < m; i++){
        for (j = 0; j < n; j++){
            ((float *)(intake_buf.buf))[i * n + j] = a[i * n + j];
            printf("%d\n", count); // 420までで止まる。なぜ？？
            count = count + 1;
        }
    }

    return 0;
}

# 実行結果
$ gcc test1.c && ./a.out
1
2
3
...
418
419
420
Segmentation fault: 11

元にしている実際に動かしたいコード

// dma_simple.h

#include <stdio.h>
#include <stdint.h>
#include <stdlib.h>
#include <unistd.h>
#include <fcntl.h>
#include <string.h>
#include <sys/types.h>
#include <sys/mman.h>

#define DMA_INTAKE_DMACR   (0x0000)
#define DMA_INTAKE_DMASR   (0x0004)
#define DMA_INTAKE_SA      (0x0018)
#define DMA_INTAKE_LENGTH  (0x0028)

#define DMA_OUTLET_DMACR   (0x0030)
#define DMA_OUTLET_DMASR   (0x0034)
#define DMA_OUTLET_DA      (0x0048)
#define DMA_OUTLET_LENGTH  (0x0058)

#define DMA_CR_RS      (1u<<0)
#define DMA_CR_RESET   (1u<<2)

#define DMA_SR_HALTED  (1u<<0)
#define DMA_SR_IDLE    (1u<<1)
#define DMA_SR_IOC_Irq (1u<<12)
#define DMA_SR_ERR_Irq (1u<<14)


static inline uint32_t regs_read32 (void* addr){
    volatile uint32_t* regs_addr = (uint32_t*)(addr);
    return *regs_addr;
}

static inline void regs_write32 (void* addr, uint32_t data){
    volatile uint32_t* regs_addr = (uint32_t*)(addr);
    * regs_addr = data;
}

static inline void dma_reset (void* regs){
    regs_write32(regs+DMA_INTAKE_DMACR, DMA_CR_RESET);
    while(regs_read32(regs+DMA_INTAKE_DMACR) & DMA_CR_RESET); // この構文謎い
    regs_write32(regs+DMA_OUTLET_DMACR, DMA_CR_RESET);
    while(regs_read32(regs+DMA_OUTLET_DMACR) & DMA_CR_RESET);
}

static inline void dma_setup (
        void* regs,
        unsigned long src_addr,
        unsigned long dst_addr
    ){
    regs_write32(regs + DMA_OUTLET_DMACR, DMA_CR_RS);
    regs_write32(regs + DMA_OUTLET_DA   , dst_addr);
    regs_write32(regs + DMA_INTAKE_DMACR, DMA_CR_RS);
    regs_write32(regs + DMA_INTAKE_SA   , src_addr);
}

static inline void dma_intake_start (void* regs, unsigned int xfer_size){
    regs_write32(regs + DMA_INTAKE_LENGTH, xfer_size);
}

static inline void dma_outlet_start (void* regs, unsigned int xfer_size){
    regs_write32(regs + DMA_OUTLET_LENGTH, xfer_size);
}

static inline void dma_wait_irq (void* regs){
    while (~regs_read32(regs + DMA_INTAKE_DMASR) & DMA_SR_IOC_Irq);
    while (~regs_read32(regs + DMA_OUTLET_DMASR) & DMA_SR_IOC_Irq);
}

static inline void dma_clear_status (void* regs){
    regs_write32(regs + DMA_INTAKE_DMASR, DMA_SR_IOC_Irq | DMA_SR_ERR_Irq);
    regs_write32(regs + DMA_OUTLET_DMASR, DMA_SR_IOC_Irq | DMA_SR_ERR_Irq);
}

struct udmabuf {
    char           name[128];
    int            file;
    unsigned char* buf;
    unsigned int   buf_size;
    unsigned long  phys_addr;
    unsigned long  debug_vma;
    unsigned long  sync_mode;
};

int udmabuf_open  (struct udmabuf* udmabuf, const char* name);
int udmabuf_close (struct udmabuf* udmabuf);

// dma_simple.c

#include "dma_simple.h"

int udmabuf_open (struct udmabuf* udmabuf, const char* name){
    char file_name[1024];
    int fd;
    unsigned char attr[1024];

    strcpy(udmabuf -> name, name);
    udmabuf -> file = -1;

    // phys_addr
    sprintf(file_name, "/sys/class/u-dma-buf/%s/phys_addr", name);
    if (
            (fd = open(file_name, O_RDONLY)) == -1
        ){
        printf("Can not open %s\n", file_name);
        return (-1);
    }
    read(fd, (void*)attr, 1024);
    sscanf(attr, "%x", &udmabuf->phys_addr);
    close(fd);

    // size
    sprintf(file_name, "/sys/class/u-dma-buf/%s/size", name);
    if (
            (fd = open(file_name, O_RDONLY)) == -1
        ){
        printf("Can not open %s\n", file_name);
        return (-1);
    }
    read(fd, (void *)attr, 1024);
    sscanf(attr, "%x", &udmabuf -> buf_size);
    close(fd);

    sprintf(file_name, "/dev/%s", name);
    if (
            (udmabuf -> file = open(file_name, O_RDWR | O_SYNC)) == -1
        ){
        printf("Can not open %s\n", file_name);
        return (-1);
    }

    udmabuf -> buf = mmap(NULL, udmabuf -> buf_size, PROT_READ|PROT_WRITE, MAP_SHARED, udmabuf -> file, 0);
    udmabuf -> debug_vma = 0;
    udmabuf -> sync_mode = 1;

    return 0;
}

int udmabuf_close(struct udmabuf* udmabuf){
    if (udmabuf -> file < 0) return -1;

    close(udmabuf -> file);
    udmabuf -> file = -1;
    return 0;
}

// matrix.c

#include "dma_simple.h"

void main(){
    int uio1_fd = open("/dev/uio4", O_RDWR);
    void *hls_regs = mmap(NULL, 0x1000, PROT_READ|PROT_WRITE, MAP_SHARED, uio1_fd, 0);

    int uio2_fd = open("/dev/uio5", O_RDWR);
    void *dma_regs = mmap(NULL, 0x1000, PROT_READ|PROT_WRITE, MAP_SHARED, uio2_fd, 0);

    struct udmabuf intake_buf;
    struct udmabuf outlet_buf;
    if (udmabuf_open(&intake_buf, "udmabuf0") == -1) exit (1);
    if (udmabuf_open(&outlet_buf, "udmabuf1") == -1) exit (1);

    dma_reset(dma_regs);
    regs_write32(hls_regs, 0x81);

    float a[32*32];
    float b[32*32];
    float c[32*32];
    float cref[32*32];
    int i, j, t;
    int m, n, k;
    m = n = k = 32;

    for (i = 0; i < m*n; i++){
        a[i] = (float) i/2.0;
        b[i] = (float) i/3.0;
        c[i] = (float) 0;
    }

    for (i = 0; i < m; i++){
        for (j = 0; j < n; j++){
            ((float *)(intake_buf.buf))[i*n + j] = a[i*n + j];
        }
    }
    for (i = 0; i < m; i++){
        for (j = 0; j < n; j++){
            ((float *)(intake_buf.buf))[i*n + j + m*m] = b[i*n + j];
        }
    }

    dma_setup(dma_regs, intake_buf.phys_addr, outlet_buf.phys_addr);

    dma_outlet_start(dma_regs, m*m*4);
    dma_intake_start(dma_regs, m*m*2*4);

    dma_wait_irq(dma_regs);
    dma_clear_status(dma_regs);

    for (i = 0; i < m; i++){
        for (j = 0; j < n; j++){
            c[i*n + j] = ((float*)(outlet_buf.buf))[i*n + j];
        }
    }

    for (i = 0; i < m; i++){
        for (j = 0; j < n; j++){
            float sum = 0;
            for (t = 0; t < k; t++){
                sum += a[i*k + t] * b[t*n + j];
            }
            cref[i*n + j] = sum;
        }
    }

    int cnt_ok = 0;
    int cnt_ng = 0;
    for (i = 0; i < m*m; i++){
        if (c[i] == cref[i]){
            cnt_ok++;
        } else {
            printf("NG: hw %f, sw %f\n", c[i], cref[i]);
            cnt_ng++;
        }
    }
    printf("OK: %d, NG: %d, Total: %d\n", cnt_ok, cnt_ng, m*m);
    udmabuf_close(&outlet_buf);
    udmabuf_close(&intake_buf);
    close(uio2_fd);
    close(uio1_fd);
}

Answer 1

またそれを解決する方法はありますか？

まず、原因については maisumakun氏から指摘がありますので割愛します。

原因を自力で切り分ける方法に関して2,3触れます。

• コンパイラの警告の活用
  コンパイル時に、オプション -Wall や -Wextra を指定しましょう。
  今回のような「未初期化」なら、コンパイラが十分新しければ警告を出してくれるので、何かマズそうだと気付けるはずです。
• コアの活用
  コアの制限がなければ、セグメンテーションフォルト発生時、コアファイルが作成されます。
  ※ただし、実行環境にも依ります。ulimit -c unlimitedコマンドで制限解除できると思いますが。
  コンパイル時に -g を指定して、デバッガ gdb でコアを読み込ませれば、問題が発生した箇所を特定し、その時の変数の値を確認できます。
• デバッガの活用
  コンパイル時に -g を指定しておけば、デバッガ gdb を使うことで動作を追うこともできます。
  ただこれは一口に言える内容ではないので、色々調べてみてください。

以下、CentOS7+devtoolset-9(gcc9)で試してみた例です。
gcc実行時に警告が出ていること、セグメンテーションフォルトにより core.6056 ファイルができていること、gdb でコアを読み込んで、intake_buf.buf を使ったアクセスの行で問題が出ていること、その時の i,j の値を p コマンドで出力していること、そういった流れの例になっています。

$ gcc -g -Wall -o test.exe test.c
test.c: In function 'main':
test.c:21:34: warning: 'intake_buf.buf' may be used uninitialized in this function [-Wmaybe-uninitialized]
   21 |             ((float *)(intake_buf.buf))[i * n + j] = a[i * n + j];
      |                       ~~~~~~~~~~~^~~~~
$ ulimit -c unlimited
$ ulimit -c
unlimited
$ ./test.exe
Segmentation fault (core dumped)
$ ls -l
total 268
-rw-------. 1 angel angel 249856 Jun  8 10:01 core.6056
-rw-r--r--. 1 angel angel    608 Jun  8 09:48 test.c
-rwxrwxr-x. 1 angel angel  19376 Jun  8 10:00 test.exe
$ gdb test.exe core.6056
(略)
Core was generated by `./test.exe'.
Program terminated with signal SIGSEGV, Segmentation fault.
#0  0x00000000004011d5 in main () at test.c:21
21                  ((float *)(intake_buf.buf))[i * n + j] = a[i * n + j];
(略)
(gdb) p i
$1 = 0
(gdb) p j
$2 = 0

Comments

[BOLTE]

ご回答ありがとうございました。gdbについては知っていたのですが、オプションを使ったりコアファイルを使うことができるのは、初めて知りました。やはり経験豊富な人に聞くとためになるなあと思いました。別の機会にまた同じようなエラーが起きたら、このコメントを読みにくることになると思います。どうもありがとうございました。

Answer 2

セグメンテーションフォールトの原因はmaisumakunさんが既に述べています。
元のソースでは
udmabuf_openの中の
udmabuf -> buf = mmap(NULL, udmabuf -> buf_size, PROT_READ|PROT_WRITE, MAP_SHARED, udmabuf -> file, 0);
でbufの初期化をしています。

bufの初期化をきちんと行えば、解決します。
以下は、その例です。
float b[32*32];を確保し、その先頭アドレスを割り当てています。

#include <stdio.h>
#include "test2.h"

int main(){
    struct udmabuf intake_buf;
    float a[32 * 32]; 
    float b[32 * 32]; 		//追加
    int i, j; // 行列の添字
    int m, n; // 行列のサイズ
    m = n = 32;
    for (i = 0; i < m*n; i++){ // 行列を初期化
        a[i] = i / 2.0; 
    }
    intake_buf.buf = (unsigned char *)b;	//追加

    int count = 0;
    for (i = 0; i < m; i++){
        for (j = 0; j < n; j++){
            ((float *)(intake_buf.buf))[i * n + j] = a[i * n + j];
            printf("%d\n", count); // 420までで止まる。なぜ？？
            count = count + 1;
        }
    }

    return 0;
}

Comments

[BOLTE]

ご回答どうもありがとうございました。tatsu99さんのおかげで元々のソースコードにおかしなところがないということを確認することができました。どうやら問題はCのコードというよりも、デバイスが使えないことによりセグメンテーションフォールとが起きているよう模様でした。

具体的な解決策をいただいたので、ベストアンサーにさせていただきます。どうもありがとうございました。

Answer 3

どうしてループの途中で、しかも決まった回数のときにsegmentation faultになるのでしょうか？

考えても仕方ありません。

intake_buf.bufは未初期化のポインタなので、そこへアクセスする操作は未定義の動作を引き起こします。何がどうなるか、一切の保証はありません。、

Comments

[maisumakun]

paiza.ioで実行すると、何も表示せずに異常終了します。

https://paiza.io/projects/JFBqdym_l0Kg-9LRntFfhg?language=c

…というように、「決まった回数のときにsegmentation faultになる」のもたまたまの結果でしかないのです（再起動すれば別な結果となるかもしれない、その程度のものです）。

[BOLTE]

素早いご返答どうもありがとうございました。maisumakunさんのおかげで何がいけないのかを理解することができました。またpaiza.ioというものもあるのですね。参考になります。