Ubuntu убивает процесс

#include <stdlib.h>
#include <stdio.h>
#include <string.h>
#include <unistd.h>
#include <fcntl.h>
#include <iostream>
#include <fstream>
#include <list>
#include <filesystem>
 
#include <sys/types.h>
#include <sys/stat.h>
#include <sys/ioctl.h>
 
#include <linux/fs.h>
#include "fiemap.h"
 
using namespace std;
namespace fs = std::filesystem;
 
//disk.cpp
struct fs_tom
{
    std::string tom_name="";
    std::string fs_type="";
    std::string mount_point="";
    std::string total_size="";
    std::string used_size="";
};
 
int fs_tom_get(std::list<fs_tom>& tom_list)
{
    fs_tom new_tom;
    char buffer[1]="";
    short fieldflag = 0, delflag = 0;
    FILE* fs_pipe = popen("df -h --output=source,fstype,target,size,used,avail| grep /dev/sd | sed \'s/ /\\:/g\'","r");
    if (fs_pipe)
    {
        while(!feof(fs_pipe))
        {
            fgets(buffer, 2, fs_pipe);
            if(buffer[0]!=':'&&buffer[0]!='\n')
            {
                delflag = 0;
                if (fieldflag==0)
                    new_tom.tom_name=new_tom.tom_name+buffer[0];
                if (fieldflag==1)
                    new_tom.fs_type=new_tom.fs_type+buffer[0];
                if (fieldflag==2)
                    new_tom.mount_point=new_tom.mount_point+buffer[0];
                if (fieldflag==3)
                    new_tom.total_size=new_tom.total_size+buffer[0];
                if (fieldflag==4)
                    new_tom.used_size=new_tom.used_size+buffer[0];
            }
            if (buffer[0]==':')
            {
                if (delflag==0)
                {
                    fieldflag+=1;
                    delflag = 1;
                }
            }
            if (buffer[0]=='\n'&&!feof(fs_pipe))
            {
                tom_list.push_back(new_tom);
                fieldflag = 0, delflag = 0;
                new_tom.fs_type="";
                new_tom.tom_name="";
                new_tom.used_size="";
                new_tom.total_size="";
                new_tom.mount_point="";
            }
        }
    }
    fclose(fs_pipe);
    return 0;
 
}
//disk.cpp
 
//extent.cpp
struct fiemap *read_fiemap(int fd)
{
    struct fiemap *fiemap;
    struct fiemap *new_fiemap;
    int extents_size;
 
    if ((fiemap = (struct fiemap*)malloc(sizeof(struct fiemap))) == NULL) {
        fprintf(stderr, "Out of memory allocating fiemap\n");   
        return NULL;
    }
    memset(fiemap, 0, sizeof(struct fiemap));
 
    fiemap->fm_start = 0;
    fiemap->fm_length = ~0;     /* Lazy */
    fiemap->fm_flags = 0;
    fiemap->fm_extent_count = 0;
    fiemap->fm_mapped_extents = 0;
    fiemap->fm_reserved = 0;
 
    /* Find out how many extents there are */
    if (ioctl(fd, FS_IOC_FIEMAP, fiemap) < 0) {
        free(fiemap);
        return NULL;
    }
    
    if(fiemap->fm_mapped_extents == 0)
    {
        free(fiemap);
        return NULL;
    }
    /* Read in the extents */
    extents_size = sizeof(struct fiemap_extent) * 
                              (fiemap->fm_mapped_extents);
 
    /* Resize fiemap to allow us to read in the extents */
    
    if ((new_fiemap = (struct fiemap*)malloc(sizeof(struct fiemap) + 
                                         extents_size)) == NULL) {
        free(fiemap);   
        return NULL;
    }
    
    new_fiemap->fm_start = fiemap->fm_start;
    new_fiemap->fm_length = fiemap->fm_length;
    new_fiemap->fm_flags = fiemap->fm_flags;
    new_fiemap->fm_extent_count = fiemap->fm_extent_count;
    new_fiemap->fm_mapped_extents = fiemap->fm_mapped_extents;
    new_fiemap->fm_reserved = fiemap->fm_reserved;
 
    memset(new_fiemap->fm_extents, 0, extents_size);
    new_fiemap->fm_extent_count = new_fiemap->fm_mapped_extents;
    new_fiemap->fm_mapped_extents = 0;
 
    if (ioctl(fd, FS_IOC_FIEMAP, new_fiemap) < 0) {
        free(fiemap);
        free(new_fiemap);
        return NULL;
    }
    free(fiemap);
    return new_fiemap;
}//extent.cpp
 
int main()
{
//Start disk.cpp
    //Get all info about disks and set it into list
    std::list<fs_tom> new_list = {};
    fs_tom_get(new_list);
    for (fs_tom new_tom: new_list)
    {
    //Create and open file with result for each disk
        ofstream new_file("res"+new_tom.tom_name.substr(6)+".txt");
        if (!new_file.is_open())
        {
            cout << "File open denied!\n";
            return -1;
        }
        //Create top of result file 
        new_file << "Tom name:" << new_tom.tom_name << '\n' << "Tom file system:" << new_tom.fs_type << '\n' << "Tom mount point:" << new_tom.mount_point  << '\n' << "Tom size:" << new_tom.total_size << '\n' << "Tom used size:" << new_tom.used_size << '\n';
        
    //Start dir.cpp
        unsigned int file_num_name = 0;
        std::list<fs::path> task_pool = {new_tom.mount_point};
        while(!task_pool.empty())
        {
            try
            {
                    for (fs::directory_entry const& current : fs::directory_iterator(task_pool.front()))
                    {
                        try
                        {
                                if (fs::exists(current))
                                {
                                    if (fs::is_regular_file(current))
                                    {
                                            new_file << file_num_name++ << '_'<< fs::file_size(current.path()) << '_' <<current.path().extension();
                                            //Start extent.cpp
                                            int fd = 0;
                                            if((fd = open(current.path().c_str(), O_RDONLY)) < 0)
                                                new_file << "_Is resident.";
                                            else
                                            {
                                                struct fiemap *fiemap;
                                                
                                                if ((fiemap = read_fiemap(fd)) != NULL)
                                                {
                                                    for (int i=0;i<fiemap->fm_mapped_extents;i++) 
                                    {
                                        new_file << '_' << fiemap->fm_extents[i].fe_physical;
                                    }
                                    free(fiemap);
                                                }
                                                else
                                                    new_file << "_Is resident.";
                                            }
                                            close(fd);
                                            //End extent.cpp
                                            new_file << endl;
                                    }
                                    if (fs::is_directory(current))
                                    {
                                        task_pool.push_back(current.path());
                                    }   
                                }
                        }
                        catch (fs::filesystem_error & e)
                        {
                                new_file << "An error occures: " << e.what() << '\n';
                        }
                    }
                    task_pool.erase(task_pool.begin());
            }
            catch (fs::filesystem_error & e)
            {
                    new_file << "An error occures: " << e.what() << '\n';
                    task_pool.erase(task_pool.begin());
            }   
        }
        
        //Close result file
        new_file.close();
        //Clear task pool
        task_pool.clear();
    // End dir.cpp
    }
 
    //Clean list of disks
    new_list.clear();
    return 0;
//End disk.cpp
}