f2fs.c 35 KB

1234567891011121314151617181920212223242526272829303132333435363738394041424344454647484950515253545556575859606162636465666768697071727374757677787980818283848586878889909192939495969798991001011021031041051061071081091101111121131141151161171181191201211221231241251261271281291301311321331341351361371381391401411421431441451461471481491501511521531541551561571581591601611621631641651661671681691701711721731741751761771781791801811821831841851861871881891901911921931941951961971981992002012022032042052062072082092102112122132142152162172182192202212222232242252262272282292302312322332342352362372382392402412422432442452462472482492502512522532542552562572582592602612622632642652662672682692702712722732742752762772782792802812822832842852862872882892902912922932942952962972982993003013023033043053063073083093103113123133143153163173183193203213223233243253263273283293303313323333343353363373383393403413423433443453463473483493503513523533543553563573583593603613623633643653663673683693703713723733743753763773783793803813823833843853863873883893903913923933943953963973983994004014024034044054064074084094104114124134144154164174184194204214224234244254264274284294304314324334344354364374384394404414424434444454464474484494504514524534544554564574584594604614624634644654664674684694704714724734744754764774784794804814824834844854864874884894904914924934944954964974984995005015025035045055065075085095105115125135145155165175185195205215225235245255265275285295305315325335345355365375385395405415425435445455465475485495505515525535545555565575585595605615625635645655665675685695705715725735745755765775785795805815825835845855865875885895905915925935945955965975985996006016026036046056066076086096106116126136146156166176186196206216226236246256266276286296306316326336346356366376386396406416426436446456466476486496506516526536546556566576586596606616626636646656666676686696706716726736746756766776786796806816826836846856866876886896906916926936946956966976986997007017027037047057067077087097107117127137147157167177187197207217227237247257267277287297307317327337347357367377387397407417427437447457467477487497507517527537547557567577587597607617627637647657667677687697707717727737747757767777787797807817827837847857867877887897907917927937947957967977987998008018028038048058068078088098108118128138148158168178188198208218228238248258268278288298308318328338348358368378388398408418428438448458468478488498508518528538548558568578588598608618628638648658668678688698708718728738748758768778788798808818828838848858868878888898908918928938948958968978988999009019029039049059069079089099109119129139149159169179189199209219229239249259269279289299309319329339349359369379389399409419429439449459469479489499509519529539549559569579589599609619629639649659669679689699709719729739749759769779789799809819829839849859869879889899909919929939949959969979989991000100110021003100410051006100710081009101010111012101310141015101610171018101910201021102210231024102510261027102810291030103110321033103410351036103710381039104010411042104310441045104610471048104910501051105210531054105510561057105810591060106110621063106410651066106710681069107010711072107310741075107610771078107910801081108210831084108510861087108810891090109110921093109410951096109710981099110011011102110311041105110611071108110911101111111211131114111511161117111811191120112111221123112411251126112711281129113011311132113311341135113611371138113911401141114211431144114511461147114811491150115111521153115411551156115711581159116011611162116311641165116611671168116911701171117211731174117511761177117811791180118111821183118411851186118711881189119011911192119311941195119611971198119912001201120212031204120512061207120812091210121112121213121412151216121712181219122012211222122312241225122612271228122912301231123212331234123512361237123812391240124112421243124412451246124712481249125012511252125312541255125612571258125912601261126212631264126512661267126812691270127112721273127412751276127712781279128012811282128312841285128612871288128912901291129212931294129512961297129812991300130113021303130413051306130713081309131013111312131313141315
  1. /*
  2. * f2fs.c - Flash-Friendly File System
  3. *
  4. * Written by Jaegeuk Kim <jaegeuk@kernel.org>
  5. *
  6. * Copyright (C) 2015 Free Software Foundation, Inc.
  7. *
  8. * GRUB is free software: you can redistribute it and/or modify
  9. * it under the terms of the GNU General Public License as published by
  10. * the Free Software Foundation, either version 3 of the License, or
  11. * (at your option) any later version.
  12. *
  13. * GRUB is distributed in the hope that it will be useful,
  14. * but WITHOUT ANY WARRANTY; without even the implied warranty of
  15. * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
  16. * GNU General Public License for more details.
  17. *
  18. * You should have received a copy of the GNU General Public License
  19. * along with GRUB. If not, see <http://www.gnu.org/licenses/>.
  20. */
  21. #include <grub/err.h>
  22. #include <grub/file.h>
  23. #include <grub/mm.h>
  24. #include <grub/misc.h>
  25. #include <grub/disk.h>
  26. #include <grub/dl.h>
  27. #include <grub/types.h>
  28. #include <grub/charset.h>
  29. #include <grub/fshelp.h>
  30. GRUB_MOD_LICENSE ("GPLv3+");
  31. /* F2FS Magic Number. */
  32. #define F2FS_SUPER_MAGIC 0xf2f52010
  33. #define CHECKSUM_OFFSET 4092 /* Must be aligned 4 bytes. */
  34. #define U32_CHECKSUM_OFFSET (CHECKSUM_OFFSET >> 2)
  35. #define CRCPOLY_LE 0xedb88320
  36. /* Byte-size offset. */
  37. #define F2FS_SUPER_OFFSET ((grub_disk_addr_t)1024)
  38. #define F2FS_SUPER_OFFSET0 (F2FS_SUPER_OFFSET >> GRUB_DISK_SECTOR_BITS)
  39. #define F2FS_SUPER_OFFSET1 ((F2FS_SUPER_OFFSET + F2FS_BLKSIZE) >> \
  40. GRUB_DISK_SECTOR_BITS)
  41. /* 9 bits for 512 bytes. */
  42. #define F2FS_MIN_LOG_SECTOR_SIZE 9
  43. /* Support only 4KB block. */
  44. #define F2FS_BLK_BITS 12
  45. #define F2FS_BLKSIZE (1 << F2FS_BLK_BITS)
  46. #define F2FS_BLK_SEC_BITS (F2FS_BLK_BITS - GRUB_DISK_SECTOR_BITS)
  47. #define VERSION_LEN 256
  48. #define F2FS_MAX_EXTENSION 64
  49. #define CP_COMPACT_SUM_FLAG 0x00000004
  50. #define CP_UMOUNT_FLAG 0x00000001
  51. #define MAX_ACTIVE_LOGS 16
  52. #define MAX_ACTIVE_NODE_LOGS 8
  53. #define MAX_ACTIVE_DATA_LOGS 8
  54. #define NR_CURSEG_DATA_TYPE 3
  55. #define NR_CURSEG_NODE_TYPE 3
  56. #define NR_CURSEG_TYPE (NR_CURSEG_DATA_TYPE + NR_CURSEG_NODE_TYPE)
  57. #define ENTRIES_IN_SUM 512
  58. #define SUMMARY_SIZE 7
  59. #define SUM_FOOTER_SIZE 5
  60. #define JENTRY_SIZE (sizeof(struct grub_f2fs_nat_jent))
  61. #define SUM_ENTRIES_SIZE (SUMMARY_SIZE * ENTRIES_IN_SUM)
  62. #define SUM_JOURNAL_SIZE (F2FS_BLKSIZE - SUM_FOOTER_SIZE - SUM_ENTRIES_SIZE)
  63. #define NAT_JOURNAL_ENTRIES ((SUM_JOURNAL_SIZE - 2) / JENTRY_SIZE)
  64. #define NAT_JOURNAL_RESERVED ((SUM_JOURNAL_SIZE - 2) % JENTRY_SIZE)
  65. #define NAT_ENTRY_SIZE (sizeof(struct grub_f2fs_nat_entry))
  66. #define NAT_ENTRY_PER_BLOCK (F2FS_BLKSIZE / NAT_ENTRY_SIZE)
  67. #define F2FS_NAME_LEN 255
  68. #define F2FS_SLOT_LEN 8
  69. #define NR_DENTRY_IN_BLOCK 214
  70. #define SIZE_OF_DIR_ENTRY 11 /* By byte. */
  71. #define BITS_PER_BYTE 8
  72. #define SIZE_OF_DENTRY_BITMAP ((NR_DENTRY_IN_BLOCK + BITS_PER_BYTE - 1) / \
  73. BITS_PER_BYTE)
  74. #define SIZE_OF_RESERVED (F2FS_BLKSIZE - \
  75. ((SIZE_OF_DIR_ENTRY + F2FS_SLOT_LEN) * \
  76. NR_DENTRY_IN_BLOCK + SIZE_OF_DENTRY_BITMAP))
  77. #define F2FS_INLINE_XATTR_ADDRS 50 /* 200 bytes for inline xattrs. */
  78. #define DEF_ADDRS_PER_INODE 923 /* Address Pointers in an Inode. */
  79. #define ADDRS_PER_BLOCK 1018 /* Address Pointers in a Direct Block. */
  80. #define NIDS_PER_BLOCK 1018 /* Node IDs in an Indirect Block. */
  81. #define NODE_DIR1_BLOCK (DEF_ADDRS_PER_INODE + 1)
  82. #define NODE_DIR2_BLOCK (DEF_ADDRS_PER_INODE + 2)
  83. #define NODE_IND1_BLOCK (DEF_ADDRS_PER_INODE + 3)
  84. #define NODE_IND2_BLOCK (DEF_ADDRS_PER_INODE + 4)
  85. #define NODE_DIND_BLOCK (DEF_ADDRS_PER_INODE + 5)
  86. #define MAX_INLINE_DATA (4 * (DEF_ADDRS_PER_INODE - \
  87. F2FS_INLINE_XATTR_ADDRS - 1))
  88. #define NR_INLINE_DENTRY (MAX_INLINE_DATA * BITS_PER_BYTE / \
  89. ((SIZE_OF_DIR_ENTRY + F2FS_SLOT_LEN) * \
  90. BITS_PER_BYTE + 1))
  91. #define INLINE_DENTRY_BITMAP_SIZE ((NR_INLINE_DENTRY + BITS_PER_BYTE - 1) / \
  92. BITS_PER_BYTE)
  93. #define INLINE_RESERVED_SIZE (MAX_INLINE_DATA - \
  94. ((SIZE_OF_DIR_ENTRY + F2FS_SLOT_LEN) * \
  95. NR_INLINE_DENTRY + \
  96. INLINE_DENTRY_BITMAP_SIZE))
  97. #define CURSEG_HOT_DATA 0
  98. #define CKPT_FLAG_SET(ckpt, f) (ckpt)->ckpt_flags & \
  99. grub_cpu_to_le32_compile_time (f)
  100. #define F2FS_INLINE_XATTR 0x01 /* File inline xattr flag. */
  101. #define F2FS_INLINE_DATA 0x02 /* File inline data flag. */
  102. #define F2FS_INLINE_DENTRY 0x04 /* File inline dentry flag. */
  103. #define F2FS_DATA_EXIST 0x08 /* File inline data exist flag. */
  104. #define F2FS_INLINE_DOTS 0x10 /* File having implicit dot dentries. */
  105. #define MAX_VOLUME_NAME 512
  106. enum FILE_TYPE
  107. {
  108. F2FS_FT_UNKNOWN,
  109. F2FS_FT_REG_FILE = 1,
  110. F2FS_FT_DIR = 2,
  111. F2FS_FT_SYMLINK = 7
  112. };
  113. struct grub_f2fs_superblock
  114. {
  115. grub_uint32_t magic;
  116. grub_uint16_t dummy1[2];
  117. grub_uint32_t log_sectorsize;
  118. grub_uint32_t log_sectors_per_block;
  119. grub_uint32_t log_blocksize;
  120. grub_uint32_t log_blocks_per_seg;
  121. grub_uint32_t segs_per_sec;
  122. grub_uint32_t secs_per_zone;
  123. grub_uint32_t checksum_offset;
  124. grub_uint8_t dummy2[40];
  125. grub_uint32_t cp_blkaddr;
  126. grub_uint32_t sit_blkaddr;
  127. grub_uint32_t nat_blkaddr;
  128. grub_uint32_t ssa_blkaddr;
  129. grub_uint32_t main_blkaddr;
  130. grub_uint32_t root_ino;
  131. grub_uint32_t node_ino;
  132. grub_uint32_t meta_ino;
  133. grub_uint8_t uuid[16];
  134. grub_uint16_t volume_name[MAX_VOLUME_NAME];
  135. grub_uint32_t extension_count;
  136. grub_uint8_t extension_list[F2FS_MAX_EXTENSION][8];
  137. grub_uint32_t cp_payload;
  138. grub_uint8_t version[VERSION_LEN];
  139. grub_uint8_t init_version[VERSION_LEN];
  140. } GRUB_PACKED;
  141. struct grub_f2fs_checkpoint
  142. {
  143. grub_uint64_t checkpoint_ver;
  144. grub_uint64_t user_block_count;
  145. grub_uint64_t valid_block_count;
  146. grub_uint32_t rsvd_segment_count;
  147. grub_uint32_t overprov_segment_count;
  148. grub_uint32_t free_segment_count;
  149. grub_uint32_t cur_node_segno[MAX_ACTIVE_NODE_LOGS];
  150. grub_uint16_t cur_node_blkoff[MAX_ACTIVE_NODE_LOGS];
  151. grub_uint32_t cur_data_segno[MAX_ACTIVE_DATA_LOGS];
  152. grub_uint16_t cur_data_blkoff[MAX_ACTIVE_DATA_LOGS];
  153. grub_uint32_t ckpt_flags;
  154. grub_uint32_t cp_pack_total_block_count;
  155. grub_uint32_t cp_pack_start_sum;
  156. grub_uint32_t valid_node_count;
  157. grub_uint32_t valid_inode_count;
  158. grub_uint32_t next_free_nid;
  159. grub_uint32_t sit_ver_bitmap_bytesize;
  160. grub_uint32_t nat_ver_bitmap_bytesize;
  161. grub_uint32_t checksum_offset;
  162. grub_uint64_t elapsed_time;
  163. grub_uint8_t alloc_type[MAX_ACTIVE_LOGS];
  164. grub_uint8_t sit_nat_version_bitmap[3900];
  165. grub_uint32_t checksum;
  166. } GRUB_PACKED;
  167. struct grub_f2fs_nat_entry {
  168. grub_uint8_t version;
  169. grub_uint32_t ino;
  170. grub_uint32_t block_addr;
  171. } GRUB_PACKED;
  172. struct grub_f2fs_nat_jent
  173. {
  174. grub_uint32_t nid;
  175. struct grub_f2fs_nat_entry ne;
  176. } GRUB_PACKED;
  177. struct grub_f2fs_nat_journal {
  178. grub_uint16_t n_nats;
  179. struct grub_f2fs_nat_jent entries[NAT_JOURNAL_ENTRIES];
  180. grub_uint8_t reserved[NAT_JOURNAL_RESERVED];
  181. } GRUB_PACKED;
  182. struct grub_f2fs_nat_block {
  183. struct grub_f2fs_nat_entry ne[NAT_ENTRY_PER_BLOCK];
  184. } GRUB_PACKED;
  185. struct grub_f2fs_dir_entry
  186. {
  187. grub_uint32_t hash_code;
  188. grub_uint32_t ino;
  189. grub_uint16_t name_len;
  190. grub_uint8_t file_type;
  191. } GRUB_PACKED;
  192. struct grub_f2fs_inline_dentry
  193. {
  194. grub_uint8_t dentry_bitmap[INLINE_DENTRY_BITMAP_SIZE];
  195. grub_uint8_t reserved[INLINE_RESERVED_SIZE];
  196. struct grub_f2fs_dir_entry dentry[NR_INLINE_DENTRY];
  197. grub_uint8_t filename[NR_INLINE_DENTRY][F2FS_SLOT_LEN];
  198. } GRUB_PACKED;
  199. struct grub_f2fs_dentry_block {
  200. grub_uint8_t dentry_bitmap[SIZE_OF_DENTRY_BITMAP];
  201. grub_uint8_t reserved[SIZE_OF_RESERVED];
  202. struct grub_f2fs_dir_entry dentry[NR_DENTRY_IN_BLOCK];
  203. grub_uint8_t filename[NR_DENTRY_IN_BLOCK][F2FS_SLOT_LEN];
  204. } GRUB_PACKED;
  205. struct grub_f2fs_inode
  206. {
  207. grub_uint16_t i_mode;
  208. grub_uint8_t i_advise;
  209. grub_uint8_t i_inline;
  210. grub_uint32_t i_uid;
  211. grub_uint32_t i_gid;
  212. grub_uint32_t i_links;
  213. grub_uint64_t i_size;
  214. grub_uint64_t i_blocks;
  215. grub_uint64_t i_atime;
  216. grub_uint64_t i_ctime;
  217. grub_uint64_t i_mtime;
  218. grub_uint32_t i_atime_nsec;
  219. grub_uint32_t i_ctime_nsec;
  220. grub_uint32_t i_mtime_nsec;
  221. grub_uint32_t i_generation;
  222. grub_uint32_t i_current_depth;
  223. grub_uint32_t i_xattr_nid;
  224. grub_uint32_t i_flags;
  225. grub_uint32_t i_pino;
  226. grub_uint32_t i_namelen;
  227. grub_uint8_t i_name[F2FS_NAME_LEN];
  228. grub_uint8_t i_dir_level;
  229. grub_uint8_t i_ext[12];
  230. grub_uint32_t i_addr[DEF_ADDRS_PER_INODE];
  231. grub_uint32_t i_nid[5];
  232. } GRUB_PACKED;
  233. struct grub_direct_node {
  234. grub_uint32_t addr[ADDRS_PER_BLOCK];
  235. } GRUB_PACKED;
  236. struct grub_indirect_node {
  237. grub_uint32_t nid[NIDS_PER_BLOCK];
  238. } GRUB_PACKED;
  239. struct grub_f2fs_node
  240. {
  241. union
  242. {
  243. struct grub_f2fs_inode i;
  244. struct grub_direct_node dn;
  245. struct grub_indirect_node in;
  246. /* Should occupy F2FS_BLKSIZE totally. */
  247. char buf[F2FS_BLKSIZE - 40];
  248. };
  249. grub_uint8_t dummy[40];
  250. } GRUB_PACKED;
  251. struct grub_fshelp_node
  252. {
  253. struct grub_f2fs_data *data;
  254. struct grub_f2fs_node inode;
  255. grub_uint32_t ino;
  256. int inode_read;
  257. };
  258. struct grub_f2fs_data
  259. {
  260. struct grub_f2fs_superblock sblock;
  261. struct grub_f2fs_checkpoint ckpt;
  262. grub_uint32_t root_ino;
  263. grub_uint32_t blocks_per_seg;
  264. grub_uint32_t cp_blkaddr;
  265. grub_uint32_t nat_blkaddr;
  266. struct grub_f2fs_nat_journal nat_j;
  267. char *nat_bitmap;
  268. grub_disk_t disk;
  269. struct grub_f2fs_node *inode;
  270. struct grub_fshelp_node diropen;
  271. };
  272. struct grub_f2fs_dir_iter_ctx
  273. {
  274. struct grub_f2fs_data *data;
  275. grub_fshelp_iterate_dir_hook_t hook;
  276. void *hook_data;
  277. grub_uint8_t *bitmap;
  278. grub_uint8_t (*filename)[F2FS_SLOT_LEN];
  279. struct grub_f2fs_dir_entry *dentry;
  280. int max;
  281. };
  282. struct grub_f2fs_dir_ctx
  283. {
  284. grub_fs_dir_hook_t hook;
  285. void *hook_data;
  286. struct grub_f2fs_data *data;
  287. };
  288. static grub_dl_t my_mod;
  289. static int
  290. grub_f2fs_test_bit_le (int nr, const grub_uint8_t *addr)
  291. {
  292. return addr[nr >> 3] & (1 << (nr & 7));
  293. }
  294. static char *
  295. get_inline_addr (struct grub_f2fs_inode *inode)
  296. {
  297. return (char *) &inode->i_addr[1];
  298. }
  299. static grub_uint64_t
  300. grub_f2fs_file_size (struct grub_f2fs_inode *inode)
  301. {
  302. return grub_le_to_cpu64 (inode->i_size);
  303. }
  304. static grub_uint32_t
  305. start_cp_addr (struct grub_f2fs_data *data)
  306. {
  307. struct grub_f2fs_checkpoint *ckpt = &data->ckpt;
  308. grub_uint32_t start_addr = data->cp_blkaddr;
  309. if (!(ckpt->checkpoint_ver & grub_cpu_to_le64_compile_time(1)))
  310. return start_addr + data->blocks_per_seg;
  311. return start_addr;
  312. }
  313. static grub_uint32_t
  314. start_sum_block (struct grub_f2fs_data *data)
  315. {
  316. struct grub_f2fs_checkpoint *ckpt = &data->ckpt;
  317. return start_cp_addr (data) + grub_le_to_cpu32 (ckpt->cp_pack_start_sum);
  318. }
  319. static grub_uint32_t
  320. sum_blk_addr (struct grub_f2fs_data *data, int base, int type)
  321. {
  322. struct grub_f2fs_checkpoint *ckpt = &data->ckpt;
  323. return start_cp_addr (data) +
  324. grub_le_to_cpu32 (ckpt->cp_pack_total_block_count) -
  325. (base + 1) + type;
  326. }
  327. static void *
  328. nat_bitmap_ptr (struct grub_f2fs_data *data)
  329. {
  330. struct grub_f2fs_checkpoint *ckpt = &data->ckpt;
  331. grub_uint32_t offset;
  332. if (grub_le_to_cpu32 (data->sblock.cp_payload) > 0)
  333. return ckpt->sit_nat_version_bitmap;
  334. offset = grub_le_to_cpu32 (ckpt->sit_ver_bitmap_bytesize);
  335. return ckpt->sit_nat_version_bitmap + offset;
  336. }
  337. static grub_uint32_t
  338. get_node_id (struct grub_f2fs_node *rn, int off, int inode_block)
  339. {
  340. if (inode_block)
  341. return grub_le_to_cpu32 (rn->i.i_nid[off - NODE_DIR1_BLOCK]);
  342. return grub_le_to_cpu32 (rn->in.nid[off]);
  343. }
  344. static grub_err_t
  345. grub_f2fs_block_read (struct grub_f2fs_data *data, grub_uint32_t blkaddr,
  346. void *buf)
  347. {
  348. return grub_disk_read (data->disk,
  349. ((grub_disk_addr_t)blkaddr) << F2FS_BLK_SEC_BITS,
  350. 0, F2FS_BLKSIZE, buf);
  351. }
  352. /* CRC32 */
  353. static grub_uint32_t
  354. grub_f2fs_cal_crc32 (const void *buf, const grub_uint32_t len)
  355. {
  356. grub_uint32_t crc = F2FS_SUPER_MAGIC;
  357. unsigned char *p = (unsigned char *)buf;
  358. grub_uint32_t tmp = len;
  359. int i;
  360. while (tmp--)
  361. {
  362. crc ^= *p++;
  363. for (i = 0; i < 8; i++)
  364. crc = (crc >> 1) ^ ((crc & 1) ? CRCPOLY_LE : 0);
  365. }
  366. return crc;
  367. }
  368. static int
  369. grub_f2fs_crc_valid (grub_uint32_t blk_crc, void *buf, const grub_uint32_t len)
  370. {
  371. grub_uint32_t cal_crc = 0;
  372. cal_crc = grub_f2fs_cal_crc32 (buf, len);
  373. return (cal_crc == blk_crc) ? 1 : 0;
  374. }
  375. static int
  376. grub_f2fs_test_bit (grub_uint32_t nr, const char *p)
  377. {
  378. int mask;
  379. p += (nr >> 3);
  380. mask = 1 << (7 - (nr & 0x07));
  381. return mask & *p;
  382. }
  383. static int
  384. grub_f2fs_sanity_check_sb (struct grub_f2fs_superblock *sb)
  385. {
  386. grub_uint32_t log_sectorsize, log_sectors_per_block;
  387. if (sb->magic != grub_cpu_to_le32_compile_time (F2FS_SUPER_MAGIC))
  388. return -1;
  389. if (sb->log_blocksize != grub_cpu_to_le32_compile_time (F2FS_BLK_BITS))
  390. return -1;
  391. log_sectorsize = grub_le_to_cpu32 (sb->log_sectorsize);
  392. log_sectors_per_block = grub_le_to_cpu32 (sb->log_sectors_per_block);
  393. if (log_sectorsize > F2FS_BLK_BITS)
  394. return -1;
  395. if (log_sectorsize < F2FS_MIN_LOG_SECTOR_SIZE)
  396. return -1;
  397. if (log_sectors_per_block + log_sectorsize != F2FS_BLK_BITS)
  398. return -1;
  399. return 0;
  400. }
  401. static int
  402. grub_f2fs_read_sb (struct grub_f2fs_data *data, grub_disk_addr_t offset)
  403. {
  404. grub_disk_t disk = data->disk;
  405. grub_err_t err;
  406. /* Read first super block. */
  407. err = grub_disk_read (disk, offset, 0, sizeof (data->sblock), &data->sblock);
  408. if (err)
  409. return -1;
  410. return grub_f2fs_sanity_check_sb (&data->sblock);
  411. }
  412. static void *
  413. validate_checkpoint (struct grub_f2fs_data *data, grub_uint32_t cp_addr,
  414. grub_uint64_t *version)
  415. {
  416. grub_uint32_t *cp_page_1, *cp_page_2;
  417. struct grub_f2fs_checkpoint *cp_block;
  418. grub_uint64_t cur_version = 0, pre_version = 0;
  419. grub_uint32_t crc = 0;
  420. grub_uint32_t crc_offset;
  421. grub_err_t err;
  422. /* Read the 1st cp block in this CP pack. */
  423. cp_page_1 = grub_malloc (F2FS_BLKSIZE);
  424. if (!cp_page_1)
  425. return NULL;
  426. err = grub_f2fs_block_read (data, cp_addr, cp_page_1);
  427. if (err)
  428. goto invalid_cp1;
  429. cp_block = (struct grub_f2fs_checkpoint *)cp_page_1;
  430. crc_offset = grub_le_to_cpu32 (cp_block->checksum_offset);
  431. if (crc_offset != CHECKSUM_OFFSET)
  432. goto invalid_cp1;
  433. crc = grub_le_to_cpu32 (*(cp_page_1 + U32_CHECKSUM_OFFSET));
  434. if (!grub_f2fs_crc_valid (crc, cp_block, crc_offset))
  435. goto invalid_cp1;
  436. pre_version = grub_le_to_cpu64 (cp_block->checkpoint_ver);
  437. /* Read the 2nd cp block in this CP pack. */
  438. cp_page_2 = grub_malloc (F2FS_BLKSIZE);
  439. if (!cp_page_2)
  440. goto invalid_cp1;
  441. cp_addr += grub_le_to_cpu32 (cp_block->cp_pack_total_block_count) - 1;
  442. err = grub_f2fs_block_read (data, cp_addr, cp_page_2);
  443. if (err)
  444. goto invalid_cp2;
  445. cp_block = (struct grub_f2fs_checkpoint *)cp_page_2;
  446. crc_offset = grub_le_to_cpu32 (cp_block->checksum_offset);
  447. if (crc_offset != CHECKSUM_OFFSET)
  448. goto invalid_cp2;
  449. crc = grub_le_to_cpu32 (*(cp_page_2 + U32_CHECKSUM_OFFSET));
  450. if (!grub_f2fs_crc_valid (crc, cp_block, crc_offset))
  451. goto invalid_cp2;
  452. cur_version = grub_le_to_cpu64 (cp_block->checkpoint_ver);
  453. if (cur_version == pre_version)
  454. {
  455. *version = cur_version;
  456. grub_free (cp_page_2);
  457. return cp_page_1;
  458. }
  459. invalid_cp2:
  460. grub_free (cp_page_2);
  461. invalid_cp1:
  462. grub_free (cp_page_1);
  463. return NULL;
  464. }
  465. static grub_err_t
  466. grub_f2fs_read_cp (struct grub_f2fs_data *data)
  467. {
  468. void *cp1, *cp2, *cur_page;
  469. grub_uint64_t cp1_version = 0, cp2_version = 0;
  470. grub_uint64_t cp_start_blk_no;
  471. /*
  472. * Finding out valid cp block involves read both
  473. * sets (cp pack1 and cp pack 2).
  474. */
  475. cp_start_blk_no = data->cp_blkaddr;
  476. cp1 = validate_checkpoint (data, cp_start_blk_no, &cp1_version);
  477. if (!cp1 && grub_errno)
  478. return grub_errno;
  479. /* The second checkpoint pack should start at the next segment. */
  480. cp_start_blk_no += data->blocks_per_seg;
  481. cp2 = validate_checkpoint (data, cp_start_blk_no, &cp2_version);
  482. if (!cp2 && grub_errno)
  483. {
  484. grub_free (cp1);
  485. return grub_errno;
  486. }
  487. if (cp1 && cp2)
  488. cur_page = (cp2_version > cp1_version) ? cp2 : cp1;
  489. else if (cp1)
  490. cur_page = cp1;
  491. else if (cp2)
  492. cur_page = cp2;
  493. else
  494. return grub_error (GRUB_ERR_BAD_FS, "no checkpoints");
  495. grub_memcpy (&data->ckpt, cur_page, F2FS_BLKSIZE);
  496. grub_free (cp1);
  497. grub_free (cp2);
  498. return 0;
  499. }
  500. static grub_err_t
  501. get_nat_journal (struct grub_f2fs_data *data)
  502. {
  503. grub_uint32_t block;
  504. char *buf;
  505. grub_err_t err;
  506. buf = grub_malloc (F2FS_BLKSIZE);
  507. if (!buf)
  508. return grub_errno;
  509. if (CKPT_FLAG_SET(&data->ckpt, CP_COMPACT_SUM_FLAG))
  510. block = start_sum_block (data);
  511. else if (CKPT_FLAG_SET (&data->ckpt, CP_UMOUNT_FLAG))
  512. block = sum_blk_addr (data, NR_CURSEG_TYPE, CURSEG_HOT_DATA);
  513. else
  514. block = sum_blk_addr (data, NR_CURSEG_DATA_TYPE, CURSEG_HOT_DATA);
  515. err = grub_f2fs_block_read (data, block, buf);
  516. if (err)
  517. goto fail;
  518. if (CKPT_FLAG_SET (&data->ckpt, CP_COMPACT_SUM_FLAG))
  519. grub_memcpy (&data->nat_j, buf, SUM_JOURNAL_SIZE);
  520. else
  521. grub_memcpy (&data->nat_j, buf + SUM_ENTRIES_SIZE, SUM_JOURNAL_SIZE);
  522. fail:
  523. grub_free (buf);
  524. return err;
  525. }
  526. static grub_uint32_t
  527. get_blkaddr_from_nat_journal (struct grub_f2fs_data *data, grub_uint32_t nid)
  528. {
  529. grub_uint16_t n = grub_le_to_cpu16 (data->nat_j.n_nats);
  530. grub_uint32_t blkaddr = 0;
  531. grub_uint16_t i;
  532. for (i = 0; i < n; i++)
  533. {
  534. if (grub_le_to_cpu32 (data->nat_j.entries[i].nid) == nid)
  535. {
  536. blkaddr = grub_le_to_cpu32 (data->nat_j.entries[i].ne.block_addr);
  537. break;
  538. }
  539. }
  540. return blkaddr;
  541. }
  542. static grub_uint32_t
  543. get_node_blkaddr (struct grub_f2fs_data *data, grub_uint32_t nid)
  544. {
  545. struct grub_f2fs_nat_block *nat_block;
  546. grub_uint32_t seg_off, block_off, entry_off, block_addr;
  547. grub_uint32_t blkaddr;
  548. grub_err_t err;
  549. blkaddr = get_blkaddr_from_nat_journal (data, nid);
  550. if (blkaddr)
  551. return blkaddr;
  552. nat_block = grub_malloc (F2FS_BLKSIZE);
  553. if (!nat_block)
  554. return 0;
  555. block_off = nid / NAT_ENTRY_PER_BLOCK;
  556. entry_off = nid % NAT_ENTRY_PER_BLOCK;
  557. seg_off = block_off / data->blocks_per_seg;
  558. block_addr = data->nat_blkaddr +
  559. ((seg_off * data->blocks_per_seg) << 1) +
  560. (block_off & (data->blocks_per_seg - 1));
  561. if (grub_f2fs_test_bit (block_off, data->nat_bitmap))
  562. block_addr += data->blocks_per_seg;
  563. err = grub_f2fs_block_read (data, block_addr, nat_block);
  564. if (err)
  565. {
  566. grub_free (nat_block);
  567. return 0;
  568. }
  569. blkaddr = grub_le_to_cpu32 (nat_block->ne[entry_off].block_addr);
  570. grub_free (nat_block);
  571. return blkaddr;
  572. }
  573. static int
  574. grub_get_node_path (struct grub_f2fs_inode *inode, grub_uint32_t block,
  575. grub_uint32_t offset[4], grub_uint32_t noffset[4])
  576. {
  577. grub_uint32_t direct_blks = ADDRS_PER_BLOCK;
  578. grub_uint32_t dptrs_per_blk = NIDS_PER_BLOCK;
  579. grub_uint32_t indirect_blks = ADDRS_PER_BLOCK * NIDS_PER_BLOCK;
  580. grub_uint32_t dindirect_blks = indirect_blks * NIDS_PER_BLOCK;
  581. grub_uint32_t direct_index = DEF_ADDRS_PER_INODE;
  582. int n = 0;
  583. int level = 0;
  584. if (inode->i_inline & F2FS_INLINE_XATTR)
  585. direct_index -= F2FS_INLINE_XATTR_ADDRS;
  586. noffset[0] = 0;
  587. if (block < direct_index)
  588. {
  589. offset[n] = block;
  590. goto got;
  591. }
  592. block -= direct_index;
  593. if (block < direct_blks)
  594. {
  595. offset[n++] = NODE_DIR1_BLOCK;
  596. noffset[n] = 1;
  597. offset[n] = block;
  598. level = 1;
  599. goto got;
  600. }
  601. block -= direct_blks;
  602. if (block < direct_blks)
  603. {
  604. offset[n++] = NODE_DIR2_BLOCK;
  605. noffset[n] = 2;
  606. offset[n] = block;
  607. level = 1;
  608. goto got;
  609. }
  610. block -= direct_blks;
  611. if (block < indirect_blks)
  612. {
  613. offset[n++] = NODE_IND1_BLOCK;
  614. noffset[n] = 3;
  615. offset[n++] = block / direct_blks;
  616. noffset[n] = 4 + offset[n - 1];
  617. offset[n] = block % direct_blks;
  618. level = 2;
  619. goto got;
  620. }
  621. block -= indirect_blks;
  622. if (block < indirect_blks)
  623. {
  624. offset[n++] = NODE_IND2_BLOCK;
  625. noffset[n] = 4 + dptrs_per_blk;
  626. offset[n++] = block / direct_blks;
  627. noffset[n] = 5 + dptrs_per_blk + offset[n - 1];
  628. offset[n] = block % direct_blks;
  629. level = 2;
  630. goto got;
  631. }
  632. block -= indirect_blks;
  633. if (block < dindirect_blks)
  634. {
  635. offset[n++] = NODE_DIND_BLOCK;
  636. noffset[n] = 5 + (dptrs_per_blk * 2);
  637. offset[n++] = block / indirect_blks;
  638. noffset[n] = 6 + (dptrs_per_blk * 2) +
  639. offset[n - 1] * (dptrs_per_blk + 1);
  640. offset[n++] = (block / direct_blks) % dptrs_per_blk;
  641. noffset[n] = 7 + (dptrs_per_blk * 2) +
  642. offset[n - 2] * (dptrs_per_blk + 1) + offset[n - 1];
  643. offset[n] = block % direct_blks;
  644. level = 3;
  645. goto got;
  646. }
  647. got:
  648. return level;
  649. }
  650. static grub_err_t
  651. grub_f2fs_read_node (struct grub_f2fs_data *data,
  652. grub_uint32_t nid, struct grub_f2fs_node *np)
  653. {
  654. grub_uint32_t blkaddr;
  655. blkaddr = get_node_blkaddr (data, nid);
  656. if (!blkaddr)
  657. return grub_errno;
  658. return grub_f2fs_block_read (data, blkaddr, np);
  659. }
  660. static struct grub_f2fs_data *
  661. grub_f2fs_mount (grub_disk_t disk)
  662. {
  663. struct grub_f2fs_data *data;
  664. grub_err_t err;
  665. data = grub_malloc (sizeof (*data));
  666. if (!data)
  667. return NULL;
  668. data->disk = disk;
  669. if (grub_f2fs_read_sb (data, F2FS_SUPER_OFFSET0))
  670. {
  671. if (grub_f2fs_read_sb (data, F2FS_SUPER_OFFSET1))
  672. {
  673. if (grub_errno == GRUB_ERR_NONE)
  674. grub_error (GRUB_ERR_BAD_FS,
  675. "not a F2FS filesystem (no superblock)");
  676. goto fail;
  677. }
  678. }
  679. data->root_ino = grub_le_to_cpu32 (data->sblock.root_ino);
  680. data->cp_blkaddr = grub_le_to_cpu32 (data->sblock.cp_blkaddr);
  681. data->nat_blkaddr = grub_le_to_cpu32 (data->sblock.nat_blkaddr);
  682. data->blocks_per_seg = 1 <<
  683. grub_le_to_cpu32 (data->sblock.log_blocks_per_seg);
  684. err = grub_f2fs_read_cp (data);
  685. if (err)
  686. goto fail;
  687. data->nat_bitmap = nat_bitmap_ptr (data);
  688. err = get_nat_journal (data);
  689. if (err)
  690. goto fail;
  691. data->diropen.data = data;
  692. data->diropen.ino = data->root_ino;
  693. data->diropen.inode_read = 1;
  694. data->inode = &data->diropen.inode;
  695. err = grub_f2fs_read_node (data, data->root_ino, data->inode);
  696. if (err)
  697. goto fail;
  698. return data;
  699. fail:
  700. grub_free (data);
  701. return NULL;
  702. }
  703. /* Guarantee inline_data was handled by caller. */
  704. static grub_disk_addr_t
  705. grub_f2fs_get_block (grub_fshelp_node_t node, grub_disk_addr_t block_ofs)
  706. {
  707. struct grub_f2fs_data *data = node->data;
  708. struct grub_f2fs_inode *inode = &node->inode.i;
  709. grub_uint32_t offset[4], noffset[4], nids[4];
  710. struct grub_f2fs_node *node_block;
  711. grub_uint32_t block_addr = -1;
  712. int level, i;
  713. level = grub_get_node_path (inode, block_ofs, offset, noffset);
  714. if (level == 0)
  715. return grub_le_to_cpu32 (inode->i_addr[offset[0]]);
  716. node_block = grub_malloc (F2FS_BLKSIZE);
  717. if (!node_block)
  718. return -1;
  719. nids[1] = get_node_id (&node->inode, offset[0], 1);
  720. /* Get indirect or direct nodes. */
  721. for (i = 1; i <= level; i++)
  722. {
  723. grub_f2fs_read_node (data, nids[i], node_block);
  724. if (grub_errno)
  725. goto fail;
  726. if (i < level)
  727. nids[i + 1] = get_node_id (node_block, offset[i], 0);
  728. }
  729. block_addr = grub_le_to_cpu32 (node_block->dn.addr[offset[level]]);
  730. fail:
  731. grub_free (node_block);
  732. return block_addr;
  733. }
  734. static grub_ssize_t
  735. grub_f2fs_read_file (grub_fshelp_node_t node,
  736. grub_disk_read_hook_t read_hook, void *read_hook_data,
  737. grub_off_t pos, grub_size_t len, char *buf)
  738. {
  739. struct grub_f2fs_inode *inode = &node->inode.i;
  740. grub_off_t filesize = grub_f2fs_file_size (inode);
  741. char *inline_addr = get_inline_addr (inode);
  742. if (inode->i_inline & F2FS_INLINE_DATA)
  743. {
  744. if (filesize > MAX_INLINE_DATA)
  745. return -1;
  746. if (len > filesize - pos)
  747. len = filesize - pos;
  748. grub_memcpy (buf, inline_addr + pos, len);
  749. return len;
  750. }
  751. return grub_fshelp_read_file (node->data->disk, node,
  752. read_hook, read_hook_data,
  753. pos, len, buf, grub_f2fs_get_block,
  754. filesize,
  755. F2FS_BLK_SEC_BITS, 0);
  756. }
  757. static char *
  758. grub_f2fs_read_symlink (grub_fshelp_node_t node)
  759. {
  760. char *symlink;
  761. struct grub_fshelp_node *diro = node;
  762. grub_uint64_t filesize;
  763. if (!diro->inode_read)
  764. {
  765. grub_f2fs_read_node (diro->data, diro->ino, &diro->inode);
  766. if (grub_errno)
  767. return 0;
  768. }
  769. filesize = grub_f2fs_file_size(&diro->inode.i);
  770. symlink = grub_malloc (filesize + 1);
  771. if (!symlink)
  772. return 0;
  773. grub_f2fs_read_file (diro, 0, 0, 0, filesize, symlink);
  774. if (grub_errno)
  775. {
  776. grub_free (symlink);
  777. return 0;
  778. }
  779. symlink[filesize] = '\0';
  780. return symlink;
  781. }
  782. static int
  783. grub_f2fs_check_dentries (struct grub_f2fs_dir_iter_ctx *ctx)
  784. {
  785. struct grub_fshelp_node *fdiro;
  786. int i;
  787. for (i = 0; i < ctx->max;)
  788. {
  789. char *filename;
  790. enum grub_fshelp_filetype type = GRUB_FSHELP_UNKNOWN;
  791. enum FILE_TYPE ftype;
  792. int name_len;
  793. int ret;
  794. if (grub_f2fs_test_bit_le (i, ctx->bitmap) == 0)
  795. {
  796. i++;
  797. continue;
  798. }
  799. ftype = ctx->dentry[i].file_type;
  800. name_len = grub_le_to_cpu16 (ctx->dentry[i].name_len);
  801. filename = grub_malloc (name_len + 1);
  802. if (!filename)
  803. return 0;
  804. grub_memcpy (filename, ctx->filename[i], name_len);
  805. filename[name_len] = 0;
  806. fdiro = grub_malloc (sizeof (struct grub_fshelp_node));
  807. if (!fdiro)
  808. {
  809. grub_free(filename);
  810. return 0;
  811. }
  812. if (ftype == F2FS_FT_DIR)
  813. type = GRUB_FSHELP_DIR;
  814. else if (ftype == F2FS_FT_SYMLINK)
  815. type = GRUB_FSHELP_SYMLINK;
  816. else if (ftype == F2FS_FT_REG_FILE)
  817. type = GRUB_FSHELP_REG;
  818. fdiro->data = ctx->data;
  819. fdiro->ino = grub_le_to_cpu32 (ctx->dentry[i].ino);
  820. fdiro->inode_read = 0;
  821. ret = ctx->hook (filename, type, fdiro, ctx->hook_data);
  822. grub_free(filename);
  823. if (ret)
  824. return 1;
  825. i += (name_len + F2FS_SLOT_LEN - 1) / F2FS_SLOT_LEN;
  826. }
  827. return 0;
  828. }
  829. static int
  830. grub_f2fs_iterate_inline_dir (struct grub_f2fs_inode *dir,
  831. struct grub_f2fs_dir_iter_ctx *ctx)
  832. {
  833. struct grub_f2fs_inline_dentry *de_blk;
  834. de_blk = (struct grub_f2fs_inline_dentry *) get_inline_addr (dir);
  835. ctx->bitmap = de_blk->dentry_bitmap;
  836. ctx->dentry = de_blk->dentry;
  837. ctx->filename = de_blk->filename;
  838. ctx->max = NR_INLINE_DENTRY;
  839. return grub_f2fs_check_dentries (ctx);
  840. }
  841. static int
  842. grub_f2fs_iterate_dir (grub_fshelp_node_t dir,
  843. grub_fshelp_iterate_dir_hook_t hook, void *hook_data)
  844. {
  845. struct grub_fshelp_node *diro = (struct grub_fshelp_node *) dir;
  846. struct grub_f2fs_inode *inode;
  847. struct grub_f2fs_dir_iter_ctx ctx = {
  848. .data = diro->data,
  849. .hook = hook,
  850. .hook_data = hook_data
  851. };
  852. grub_off_t fpos = 0;
  853. if (!diro->inode_read)
  854. {
  855. grub_f2fs_read_node (diro->data, diro->ino, &diro->inode);
  856. if (grub_errno)
  857. return 0;
  858. }
  859. inode = &diro->inode.i;
  860. if (inode->i_inline & F2FS_INLINE_DENTRY)
  861. return grub_f2fs_iterate_inline_dir (inode, &ctx);
  862. while (fpos < grub_f2fs_file_size (inode))
  863. {
  864. struct grub_f2fs_dentry_block *de_blk;
  865. char *buf;
  866. int ret;
  867. buf = grub_zalloc (F2FS_BLKSIZE);
  868. if (!buf)
  869. return 0;
  870. grub_f2fs_read_file (diro, 0, 0, fpos, F2FS_BLKSIZE, buf);
  871. if (grub_errno)
  872. {
  873. grub_free (buf);
  874. return 0;
  875. }
  876. de_blk = (struct grub_f2fs_dentry_block *) buf;
  877. ctx.bitmap = de_blk->dentry_bitmap;
  878. ctx.dentry = de_blk->dentry;
  879. ctx.filename = de_blk->filename;
  880. ctx.max = NR_DENTRY_IN_BLOCK;
  881. ret = grub_f2fs_check_dentries (&ctx);
  882. grub_free (buf);
  883. if (ret)
  884. return 1;
  885. fpos += F2FS_BLKSIZE;
  886. }
  887. return 0;
  888. }
  889. static int
  890. grub_f2fs_dir_iter (const char *filename, enum grub_fshelp_filetype filetype,
  891. grub_fshelp_node_t node, void *data)
  892. {
  893. struct grub_f2fs_dir_ctx *ctx = data;
  894. struct grub_dirhook_info info;
  895. grub_memset (&info, 0, sizeof (info));
  896. if (!node->inode_read)
  897. {
  898. grub_f2fs_read_node (ctx->data, node->ino, &node->inode);
  899. if (!grub_errno)
  900. node->inode_read = 1;
  901. grub_errno = GRUB_ERR_NONE;
  902. }
  903. if (node->inode_read)
  904. {
  905. info.mtimeset = 1;
  906. info.mtime = grub_le_to_cpu64 (node->inode.i.i_mtime);
  907. }
  908. info.dir = ((filetype & GRUB_FSHELP_TYPE_MASK) == GRUB_FSHELP_DIR);
  909. grub_free (node);
  910. return ctx->hook (filename, &info, ctx->hook_data);
  911. }
  912. static grub_err_t
  913. grub_f2fs_dir (grub_device_t device, const char *path,
  914. grub_fs_dir_hook_t hook, void *hook_data)
  915. {
  916. struct grub_f2fs_dir_ctx ctx = {
  917. .hook = hook,
  918. .hook_data = hook_data
  919. };
  920. struct grub_fshelp_node *fdiro = 0;
  921. grub_dl_ref (my_mod);
  922. ctx.data = grub_f2fs_mount (device->disk);
  923. if (!ctx.data)
  924. goto fail;
  925. grub_fshelp_find_file (path, &ctx.data->diropen, &fdiro,
  926. grub_f2fs_iterate_dir, grub_f2fs_read_symlink,
  927. GRUB_FSHELP_DIR);
  928. if (grub_errno)
  929. goto fail;
  930. grub_f2fs_iterate_dir (fdiro, grub_f2fs_dir_iter, &ctx);
  931. fail:
  932. if (fdiro != &ctx.data->diropen)
  933. grub_free (fdiro);
  934. grub_free (ctx.data);
  935. grub_dl_unref (my_mod);
  936. return grub_errno;
  937. }
  938. /* Open a file named NAME and initialize FILE. */
  939. static grub_err_t
  940. grub_f2fs_open (struct grub_file *file, const char *name)
  941. {
  942. struct grub_f2fs_data *data = NULL;
  943. struct grub_fshelp_node *fdiro = 0;
  944. struct grub_f2fs_inode *inode;
  945. grub_dl_ref (my_mod);
  946. data = grub_f2fs_mount (file->device->disk);
  947. if (!data)
  948. goto fail;
  949. grub_fshelp_find_file (name, &data->diropen, &fdiro,
  950. grub_f2fs_iterate_dir, grub_f2fs_read_symlink,
  951. GRUB_FSHELP_REG);
  952. if (grub_errno)
  953. goto fail;
  954. if (!fdiro->inode_read)
  955. {
  956. grub_f2fs_read_node (data, fdiro->ino, &fdiro->inode);
  957. if (grub_errno)
  958. goto fail;
  959. }
  960. grub_memcpy (data->inode, &fdiro->inode, sizeof (*data->inode));
  961. grub_free (fdiro);
  962. inode = &(data->inode->i);
  963. file->size = grub_f2fs_file_size (inode);
  964. file->data = data;
  965. file->offset = 0;
  966. if (inode->i_inline & F2FS_INLINE_DATA && file->size > MAX_INLINE_DATA)
  967. grub_error (GRUB_ERR_BAD_FS, "corrupted inline_data: need fsck");
  968. return 0;
  969. fail:
  970. if (fdiro != &data->diropen)
  971. grub_free (fdiro);
  972. grub_free (data);
  973. grub_dl_unref (my_mod);
  974. return grub_errno;
  975. }
  976. static grub_ssize_t
  977. grub_f2fs_read (grub_file_t file, char *buf, grub_size_t len)
  978. {
  979. struct grub_f2fs_data *data = (struct grub_f2fs_data *) file->data;
  980. return grub_f2fs_read_file (&data->diropen,
  981. file->read_hook, file->read_hook_data,
  982. file->offset, len, buf);
  983. }
  984. static grub_err_t
  985. grub_f2fs_close (grub_file_t file)
  986. {
  987. struct grub_f2fs_data *data = (struct grub_f2fs_data *) file->data;
  988. grub_free (data);
  989. grub_dl_unref (my_mod);
  990. return GRUB_ERR_NONE;
  991. }
  992. static grub_uint8_t *
  993. grub_f2fs_utf16_to_utf8 (grub_uint16_t *in_buf_le)
  994. {
  995. grub_uint16_t in_buf[MAX_VOLUME_NAME];
  996. grub_uint8_t *out_buf;
  997. int len = 0;
  998. out_buf = grub_malloc (MAX_VOLUME_NAME * GRUB_MAX_UTF8_PER_UTF16 + 1);
  999. if (!out_buf)
  1000. return NULL;
  1001. while (*in_buf_le != 0 && len < MAX_VOLUME_NAME) {
  1002. in_buf[len] = grub_le_to_cpu16 (in_buf_le[len]);
  1003. len++;
  1004. }
  1005. *grub_utf16_to_utf8 (out_buf, in_buf, len) = '\0';
  1006. return out_buf;
  1007. }
  1008. static grub_err_t
  1009. grub_f2fs_label (grub_device_t device, char **label)
  1010. {
  1011. struct grub_f2fs_data *data;
  1012. grub_disk_t disk = device->disk;
  1013. grub_dl_ref (my_mod);
  1014. data = grub_f2fs_mount (disk);
  1015. if (data)
  1016. *label = (char *) grub_f2fs_utf16_to_utf8 (data->sblock.volume_name);
  1017. else
  1018. *label = NULL;
  1019. grub_free (data);
  1020. grub_dl_unref (my_mod);
  1021. return grub_errno;
  1022. }
  1023. static grub_err_t
  1024. grub_f2fs_uuid (grub_device_t device, char **uuid)
  1025. {
  1026. struct grub_f2fs_data *data;
  1027. grub_disk_t disk = device->disk;
  1028. grub_dl_ref (my_mod);
  1029. data = grub_f2fs_mount (disk);
  1030. if (data)
  1031. {
  1032. *uuid =
  1033. grub_xasprintf
  1034. ("%02x%02x%02x%02x-%02x%02x-%02x%02x-%02x%02x-%02x%02x%02x%02x%02x%02x",
  1035. data->sblock.uuid[0], data->sblock.uuid[1],
  1036. data->sblock.uuid[2], data->sblock.uuid[3],
  1037. data->sblock.uuid[4], data->sblock.uuid[5],
  1038. data->sblock.uuid[6], data->sblock.uuid[7],
  1039. data->sblock.uuid[8], data->sblock.uuid[9],
  1040. data->sblock.uuid[10], data->sblock.uuid[11],
  1041. data->sblock.uuid[12], data->sblock.uuid[13],
  1042. data->sblock.uuid[14], data->sblock.uuid[15]);
  1043. }
  1044. else
  1045. *uuid = NULL;
  1046. grub_free (data);
  1047. grub_dl_unref (my_mod);
  1048. return grub_errno;
  1049. }
  1050. static struct grub_fs grub_f2fs_fs = {
  1051. .name = "f2fs",
  1052. .fs_dir = grub_f2fs_dir,
  1053. .fs_open = grub_f2fs_open,
  1054. .fs_read = grub_f2fs_read,
  1055. .fs_close = grub_f2fs_close,
  1056. .fs_label = grub_f2fs_label,
  1057. .fs_uuid = grub_f2fs_uuid,
  1058. #ifdef GRUB_UTIL
  1059. .reserved_first_sector = 1,
  1060. .blocklist_install = 0,
  1061. #endif
  1062. .next = 0
  1063. };
  1064. GRUB_MOD_INIT (f2fs)
  1065. {
  1066. grub_fs_register (&grub_f2fs_fs);
  1067. my_mod = mod;
  1068. }
  1069. GRUB_MOD_FINI (f2fs)
  1070. {
  1071. grub_fs_unregister (&grub_f2fs_fs);
  1072. }