자유 게시판

HxD로 살펴본 바 역시나 절망적이네요.

2013.09.29 19:57

빛과그림자 조회:1103

파티션만 삭제했으나 어떤 도구로도 복구가 안되자

파티션 테이블을 직접 만들어보려고 헥사로 살펴보니 앞부분에 리눅스에서나 쓰이는 관련 문자열들이 주루룩 있네요.

이것은 FAT를 넘어 루트 디렉토리까지 날라갔음을 의미하는듯 하네요.


실은 나스용 미니 리눅스 이미지를 2GB SD카드에 넣으려다 2TB에 시도했던것 같습니다.

당시 파티션만 삭제한것으로 기억되지만 살펴보니 쓰기시도가 있었나 봅니다.


결국 앞부분 300MB 정도가 모두 리눅스로 채워진듯 보이며

이제 원상복구는 포기하고 뒤쪽의 남은거나 건져볼 샘으로 동일한 파일시스템으로 포맷후 차분히 검색하고 있습니다.


마소는 아직까지 FAT64 관련 소스를 제대로 공개하지 않은듯 한데 (NTFS와 같은 버전 업그레이드 역시 없고...)

가급적 FAT 64는 멀리하시고 중요한건 백업들 잘하세요.


다음은 구글신께 물어 찾아본 exFAT 관련 헤더파일 입니다.



1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
/*
        exfat.h (29.08.09)
        Definitions of structures and constants used in exFAT file system
        implementation.

        Copyright (C) 2010-2013  Andrew Nayenko

        This program is free software: you can redistribute it and/or modify
        it under the terms of the GNU General Public License as published by
        the Free Software Foundation, either version 3 of the License, or
        (at your option) any later version.

        This program is distributed in the hope that it will be useful,
        but WITHOUT ANY WARRANTY; without even the implied warranty of
        MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
        GNU General Public License for more details.

        You should have received a copy of the GNU General Public License
        along with this program.  If not, see <https://www.gnu.org/licenses/>.
*/

#ifndef EXFAT_H_INCLUDED
#define EXFAT_H_INCLUDED

#include <stdio.h>
#include <stdlib.h>
#include <time.h>
#include <stdbool.h>
#include <sys/stat.h>
#include <sys/types.h>
#include "compiler.h"
#include "exfatfs.h"
#include "version.h"

#define EXFAT_NAME_MAX 256
#define EXFAT_ATTRIB_CONTIGUOUS 0x10000
#define EXFAT_ATTRIB_CACHED     0x20000
#define EXFAT_ATTRIB_DIRTY      0x40000
#define EXFAT_ATTRIB_UNLINKED   0x80000
#define IS_CONTIGUOUS(node) (((node).flags & EXFAT_ATTRIB_CONTIGUOUS) != 0)
#define SECTOR_SIZE(sb) (1 << (sb).sector_bits)
#define CLUSTER_SIZE(sb) (SECTOR_SIZE(sb) << (sb).spc_bits)
#define CLUSTER_INVALID(c) \
        ((c) < EXFAT_FIRST_DATA_CLUSTER || (c) > EXFAT_LAST_DATA_CLUSTER)

#define MIN(a, b) ((a) < (b) ? (a) : (b))
#define MAX(a, b) ((a) > (b) ? (a) : (b))
#define DIV_ROUND_UP(x, d) (((x) + (d) - 1) / (d))
#define ROUND_UP(x, d) (DIV_ROUND_UP(x, d) * (d))
#define UTF8_BYTES(c) ((c) * 6) /* UTF-8 character can occupy up to 6 bytes */

#define BMAP_GET(bitmap, index) \
        (((uint8_t*) bitmap)[(index) / 8] & (1u << ((index) % 8)))
#define BMAP_SET(bitmap, index) \
        ((uint8_t*) bitmap)[(index) / 8] |= (1u << ((index) % 8))
#define BMAP_CLR(bitmap, index) \
        ((uint8_t*) bitmap)[(index) / 8] &= ~(1u << ((index) % 8))

struct exfat_node
{
        struct exfat_node* parent;
        struct exfat_node* child;
        struct exfat_node* next;
        struct exfat_node* prev;

        int references;
        uint32_t fptr_index;
        cluster_t fptr_cluster;
        cluster_t entry_cluster;
        off_t entry_offset;
        cluster_t start_cluster;
        int flags;
        uint64_t size;
        time_t mtime, atime;
        le16_t name[EXFAT_NAME_MAX + 1];
};

enum exfat_mode
{
        EXFAT_MODE_RO,
        EXFAT_MODE_RW,
        EXFAT_MODE_ANY,
};

struct exfat_dev;

struct exfat
{
        struct exfat_dev* dev;
        struct exfat_super_block* sb;
        le16_t* upcase;
        size_t upcase_chars;
        struct exfat_node* root;
        struct
        {
                cluster_t start_cluster;
                uint32_t size;                          /* in bits */
                uint8_t* chunk;
                uint32_t chunk_size;            /* in bits */
                bool dirty;
        }
        cmap;
        char label[UTF8_BYTES(EXFAT_ENAME_MAX) + 1];
        void* zero_cluster;
        int dmask, fmask;
        uid_t uid;
        gid_t gid;
        int ro;
        bool noatime;
};

/* in-core nodes iterator */
struct exfat_iterator
{
        struct exfat_node* parent;
        struct exfat_node* current;
};

struct exfat_human_bytes
{
        uint64_t value;
        const char* unit;
};

extern int exfat_errors;

void exfat_bug(const char* format, ...) PRINTF NORETURN;
void exfat_error(const char* format, ...) PRINTF;
void exfat_warn(const char* format, ...) PRINTF;
void exfat_debug(const char* format, ...) PRINTF;

struct exfat_dev* exfat_open(const char* spec, enum exfat_mode mode);
int exfat_close(struct exfat_dev* dev);
int exfat_fsync(struct exfat_dev* dev);
enum exfat_mode exfat_get_mode(const struct exfat_dev* dev);
off_t exfat_get_size(const struct exfat_dev* dev);
off_t exfat_seek(struct exfat_dev* dev, off_t offset, int whence);
ssize_t exfat_read(struct exfat_dev* dev, void* buffer, size_t size);
ssize_t exfat_write(struct exfat_dev* dev, const void* buffer, size_t size);
void exfat_pread(struct exfat_dev* dev, void* buffer, size_t size,
                off_t offset);
void exfat_pwrite(struct exfat_dev* dev, const void* buffer, size_t size,
                off_t offset);
ssize_t exfat_generic_pread(const struct exfat* ef, struct exfat_node* node,
                void* buffer, size_t size, off_t offset);
ssize_t exfat_generic_pwrite(struct exfat* ef, struct exfat_node* node,
                const void* buffer, size_t size, off_t offset);

int exfat_opendir(struct exfat* ef, struct exfat_node* dir,
                struct exfat_iterator* it);
void exfat_closedir(struct exfat* ef, struct exfat_iterator* it);
struct exfat_node* exfat_readdir(struct exfat* ef, struct exfat_iterator* it);
int exfat_lookup(struct exfat* ef, struct exfat_node** node,
                const char* path);
int exfat_split(struct exfat* ef, struct exfat_node** parent,
                struct exfat_node** node, le16_t* name, const char* path);

off_t exfat_c2o(const struct exfat* ef, cluster_t cluster);
cluster_t exfat_next_cluster(const struct exfat* ef,
                const struct exfat_node* node, cluster_t cluster);
cluster_t exfat_advance_cluster(const struct exfat* ef,
                struct exfat_node* node, uint32_t count);
void exfat_flush_cmap(struct exfat* ef);
int exfat_truncate(struct exfat* ef, struct exfat_node* node, uint64_t size,
                bool erase);
uint32_t exfat_count_free_clusters(const struct exfat* ef);
int exfat_find_used_sectors(const struct exfat* ef, off_t* a, off_t* b);

void exfat_stat(const struct exfat* ef, const struct exfat_node* node,
                struct stat* stbuf);
void exfat_get_name(const struct exfat_node* node, char* buffer, size_t n);
uint16_t exfat_start_checksum(const struct exfat_entry_meta1* entry);
uint16_t exfat_add_checksum(const void* entry, uint16_t sum);
le16_t exfat_calc_checksum(const struct exfat_entry_meta1* meta1,
                const struct exfat_entry_meta2* meta2, const le16_t* name);
uint32_t exfat_vbr_start_checksum(const void* sector, size_t size);
uint32_t exfat_vbr_add_checksum(const void* sector, size_t size, uint32_t sum);
le16_t exfat_calc_name_hash(const struct exfat* ef, const le16_t* name);
void exfat_humanize_bytes(uint64_t value, struct exfat_human_bytes* hb);
void exfat_print_info(const struct exfat_super_block* sb,
                uint32_t free_clusters);

int utf16_to_utf8(char* output, const le16_t* input, size_t outsize,
                size_t insize);
int utf8_to_utf16(le16_t* output, const char* input, size_t outsize,
                size_t insize);
size_t utf16_length(const le16_t* str);

struct exfat_node* exfat_get_node(struct exfat_node* node);
void exfat_put_node(struct exfat* ef, struct exfat_node* node);
int exfat_cache_directory(struct exfat* ef, struct exfat_node* dir);
void exfat_reset_cache(struct exfat* ef);
void exfat_flush_node(struct exfat* ef, struct exfat_node* node);
int exfat_unlink(struct exfat* ef, struct exfat_node* node);
int exfat_rmdir(struct exfat* ef, struct exfat_node* node);
int exfat_mknod(struct exfat* ef, const char* path);
int exfat_mkdir(struct exfat* ef, const char* path);
int exfat_rename(struct exfat* ef, const char* old_path, const char* new_path);
void exfat_utimes(struct exfat_node* node, const struct timespec tv[2]);
void exfat_update_atime(struct exfat_node* node);
void exfat_update_mtime(struct exfat_node* node);
const char* exfat_get_label(struct exfat* ef);
int exfat_set_label(struct exfat* ef, const char* label);

int exfat_mount(struct exfat* ef, const char* spec, const char* options);
void exfat_unmount(struct exfat* ef);

time_t exfat_exfat2unix(le16_t date, le16_t time, uint8_t centisec);
void exfat_unix2exfat(time_t unix_time, le16_t* date, le16_t* time,
                uint8_t* centisec);
void exfat_tzset(void);

#endif /* ifndef EXFAT_H_INCLUDED */






1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
/*
        exfatfs.h (29.08.09)
        Definitions of structures and constants used in exFAT file system.

        Copyright (C) 2010-2013  Andrew Nayenko

        This program is free software: you can redistribute it and/or modify
        it under the terms of the GNU General Public License as published by
        the Free Software Foundation, either version 3 of the License, or
        (at your option) any later version.

        This program is distributed in the hope that it will be useful,
        but WITHOUT ANY WARRANTY; without even the implied warranty of
        MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
        GNU General Public License for more details.

        You should have received a copy of the GNU General Public License
        along with this program.  If not, see <https://www.gnu.org/licenses/>.
*/

#ifndef EXFATFS_H_INCLUDED
#define EXFATFS_H_INCLUDED

#include "byteorder.h"

typedef uint32_t cluster_t;             /* cluster number */

#define EXFAT_FIRST_DATA_CLUSTER 2
#define EXFAT_LAST_DATA_CLUSTER 0xfffffff6

#define EXFAT_CLUSTER_FREE         0 /* free cluster */
#define EXFAT_CLUSTER_BAD 0xfffffff7 /* cluster contains bad sector */
#define EXFAT_CLUSTER_END 0xffffffff /* final cluster of file or directory */

#define EXFAT_STATE_MOUNTED 2

struct exfat_super_block
{
        uint8_t jump[3];                                /* 0x00 jmp and nop instructions */
        uint8_t oem_name[8];                    /* 0x03 "EXFAT   " */
        uint8_t __unused1[53];                  /* 0x0B always 0 */
        le64_t sector_start;                    /* 0x40 partition first sector */
        le64_t sector_count;                    /* 0x48 partition sectors count */
        le32_t fat_sector_start;                /* 0x50 FAT first sector */
        le32_t fat_sector_count;                /* 0x54 FAT sectors count */
        le32_t cluster_sector_start;    /* 0x58 first cluster sector */
        le32_t cluster_count;                   /* 0x5C total clusters count */
        le32_t rootdir_cluster;                 /* 0x60 first cluster of the root dir */
        le32_t volume_serial;                   /* 0x64 volume serial number */
        struct                                                  /* 0x68 FS version */
        {
                uint8_t minor;
                uint8_t major;
        }
        version;
        le16_t volume_state;                    /* 0x6A volume state flags */
        uint8_t sector_bits;                    /* 0x6C sector size as (1 << n) */
        uint8_t spc_bits;                               /* 0x6D sectors per cluster as (1 << n) */
        uint8_t fat_count;                              /* 0x6E always 1 */
        uint8_t drive_no;                               /* 0x6F always 0x80 */
        uint8_t allocated_percent;              /* 0x70 percentage of allocated space */
        uint8_t __unused2[397];                 /* 0x71 always 0 */
        le16_t boot_signature;                  /* the value of 0xAA55 */
}
PACKED;
STATIC_ASSERT(sizeof(struct exfat_super_block) == 512);

#define EXFAT_ENTRY_VALID     0x80
#define EXFAT_ENTRY_CONTINUED 0x40

#define EXFAT_ENTRY_BITMAP    (0x01 | EXFAT_ENTRY_VALID)
#define EXFAT_ENTRY_UPCASE    (0x02 | EXFAT_ENTRY_VALID)
#define EXFAT_ENTRY_LABEL     (0x03 | EXFAT_ENTRY_VALID)
#define EXFAT_ENTRY_FILE      (0x05 | EXFAT_ENTRY_VALID)
#define EXFAT_ENTRY_FILE_INFO (0x00 | EXFAT_ENTRY_VALID | EXFAT_ENTRY_CONTINUED)
#define EXFAT_ENTRY_FILE_NAME (0x01 | EXFAT_ENTRY_VALID | EXFAT_ENTRY_CONTINUED)

struct exfat_entry                                      /* common container for all entries */
{
        uint8_t type;                                   /* any of EXFAT_ENTRY_xxx */
        uint8_t data[31];
}
PACKED;
STATIC_ASSERT(sizeof(struct exfat_entry) == 32);

#define EXFAT_ENAME_MAX 15

struct exfat_entry_bitmap                       /* allocated clusters bitmap */
{
        uint8_t type;                                   /* EXFAT_ENTRY_BITMAP */
        uint8_t __unknown1[19];
        le32_t start_cluster;
        le64_t size;                                    /* in bytes */
}
PACKED;
STATIC_ASSERT(sizeof(struct exfat_entry_bitmap) == 32);

struct exfat_entry_upcase                       /* upper case translation table */
{
        uint8_t type;                                   /* EXFAT_ENTRY_UPCASE */
        uint8_t __unknown1[3];
        le32_t checksum;
        uint8_t __unknown2[12];
        le32_t start_cluster;
        le64_t size;                                    /* in bytes */
}
PACKED;
STATIC_ASSERT(sizeof(struct exfat_entry_upcase) == 32);

struct exfat_entry_label                        /* volume label */
{
        uint8_t type;                                   /* EXFAT_ENTRY_LABEL */
        uint8_t length;                                 /* number of characters */
        le16_t name[EXFAT_ENAME_MAX];   /* in UTF-16LE */
}
PACKED;
STATIC_ASSERT(sizeof(struct exfat_entry_label) == 32);

#define EXFAT_ATTRIB_RO     0x01
#define EXFAT_ATTRIB_HIDDEN 0x02
#define EXFAT_ATTRIB_SYSTEM 0x04
#define EXFAT_ATTRIB_VOLUME 0x08
#define EXFAT_ATTRIB_DIR    0x10
#define EXFAT_ATTRIB_ARCH   0x20

struct exfat_entry_meta1                        /* file or directory info (part 1) */
{
        uint8_t type;                                   /* EXFAT_ENTRY_FILE */
        uint8_t continuations;
        le16_t checksum;
        le16_t attrib;                                  /* combination of EXFAT_ATTRIB_xxx */
        le16_t __unknown1;
        le16_t crtime, crdate;                  /* creation date and time */
        le16_t mtime, mdate;                    /* latest modification date and time */
        le16_t atime, adate;                    /* latest access date and time */
        uint8_t crtime_cs;                              /* creation time in cs (centiseconds) */
        uint8_t mtime_cs;                               /* latest modification time in cs */
        uint8_t __unknown2[10];
}
PACKED;
STATIC_ASSERT(sizeof(struct exfat_entry_meta1) == 32);

#define EXFAT_FLAG_ALWAYS1              (1u << 0)
#define EXFAT_FLAG_CONTIGUOUS   (1u << 1)

struct exfat_entry_meta2                        /* file or directory info (part 2) */
{
        uint8_t type;                                   /* EXFAT_ENTRY_FILE_INFO */
        uint8_t flags;                                  /* combination of EXFAT_FLAG_xxx */
        uint8_t __unknown1;
        uint8_t name_length;
        le16_t name_hash;
        le16_t __unknown2;
        le64_t real_size;                               /* in bytes, equals to size */
        uint8_t __unknown3[4];
        le32_t start_cluster;
        le64_t size;                                    /* in bytes, equals to real_size */
}
PACKED;
STATIC_ASSERT(sizeof(struct exfat_entry_meta2) == 32);

struct exfat_entry_name                         /* file or directory name */
{
        uint8_t type;                                   /* EXFAT_ENTRY_FILE_NAME */
        uint8_t __unknown;
        le16_t name[EXFAT_ENAME_MAX];   /* in UTF-16LE */
}
PACKED;
STATIC_ASSERT(sizeof(struct exfat_entry_name) == 32);

#endif /* ifndef EXFATFS_H_INCLUDED */
https://windowsforum.kr/free/4976243 홈으로 위로 목록
홈으로 위로 목록
번호 제목 글쓴이 조회 등록일
[공지] 자유 게시판 이용간 유의사항 (정치, 종교, 시사 게시물 자제) [1] gooddew - -
19010 iptime 펌웨어에 문제 있다고 전화 왔네요. [6] 마스크 2290 10-04
19009 고딩때 절도자가 현재 성인이 되었군요 [21] 트리니티 2176 10-04
19008 인터넷으로 낚시하시는 사람들 [2] DOS 1181 10-04
19007 [잡담] 돼지 한마리 배 땄습니다..ㅎㅎㅎ [6] 초원의빛 1696 10-04
19006 파일 다운로더 생성 매니저 v1.2 - 2013/10/04 [3] 뉴타입01호 1394 10-04
19005 악성 프로그램 대응 트리니티 1324 10-04
19004 카리스마조 봐라 [14] 크리에이티 4818 10-04
19003 사전 방역 기능 [7] 트리니티 1577 10-04
19002 오랜만에 PE 한번 만져봐야겠네요. [4] suk 3308 10-04
19001 옳고 그름의 문제... [1] 구디 1099 10-04
19000 무슨일인지 커뮤니티가 시끄럽네요. [2] 백스페이스 1237 10-04
18999 능력자분들께 [5] 내리사랑 1818 10-04
18998 강좌 팁 게시판 스크랩 기능이 없나요 [1] 제스트- 980 10-03
18997 게시판 ip 까보면 큰일 납니까? [12] 박군 1690 10-03
18996 티스토리 초대장 (이메일 확인 해보세요) [3] k-style 1055 10-03
18995 운영자분 답변해 보시기 바랍니다. [5] 크리에이티 1883 10-03
18994 다운로더 생성 매니저는 사망하였습니다. [7] 뉴타입01호 1293 10-03
18993 중국 검색엔진 바이두에서 제공하는 바이두 백신 [5] 건강회복 3676 10-03
18992 게시판 ip까봅시다. [17] 크리에이티 1853 10-03
18991 회원님들 이런 달력은 이름이 뭐고 어서 구합니까?? [9] ㄷㄱ 1757 10-03
홈으로 위로 목록
XE1.11.6 Layout1.4.8