From mboxrd@z Thu Jan 1 00:00:00 1970 Received: from list by lists.gnu.org with archive (Exim 4.71) id 1aXvAw-0004ji-HG for mharc-grub-devel@gnu.org; Mon, 22 Feb 2016 13:25:38 -0500 Received: from eggs.gnu.org ([2001:4830:134:3::10]:59535) by lists.gnu.org with esmtp (Exim 4.71) (envelope-from ) id 1aXvAq-0004iw-8w for grub-devel@gnu.org; Mon, 22 Feb 2016 13:25:36 -0500 Received: from Debian-exim by eggs.gnu.org with spam-scanned (Exim 4.71) (envelope-from ) id 1aXvAi-0001NJ-Rz for grub-devel@gnu.org; Mon, 22 Feb 2016 13:25:31 -0500 Received: from mail.kernel.org ([198.145.29.136]:47252) by eggs.gnu.org with esmtp (Exim 4.71) (envelope-from ) id 1aXvAi-0001N4-Eb for grub-devel@gnu.org; Mon, 22 Feb 2016 13:25:24 -0500 Received: from mail.kernel.org (localhost [127.0.0.1]) by mail.kernel.org (Postfix) with ESMTP id 3A30F2054B; Mon, 22 Feb 2016 18:25:21 +0000 (UTC) Received: from localhost (107-1-141-74-ip-static.hfc.comcastbusiness.net [107.1.141.74]) (using TLSv1.2 with cipher AES128-GCM-SHA256 (128/128 bits)) (No client certificate requested) by mail.kernel.org (Postfix) with ESMTPSA id 22C0720531; Mon, 22 Feb 2016 18:25:18 +0000 (UTC) Date: Mon, 22 Feb 2016 10:25:25 -0800 From: Jaegeuk Kim To: Andrei Borzenkov Subject: Re: [f2fs-dev] [PATCH v7] F2FS support Message-ID: <20160222182525.GD10875@jaegeuk.gateway> References: <1427185140-41120-1-git-send-email-jaegeuk@kernel.org> <20150403224908.GB25673@jaegeuk-mac02.mot.com> <20151119212824.GA11666@jaegeuk.local> <566E7DAA.4010202@gmail.com> <20151215003421.GD48918@jaegeuk.local> <20151215181439.GA60773@jaegeuk.local> <20160108194132.GA17464@jaegeuk.aosp> MIME-Version: 1.0 Content-Type: text/plain; charset=utf-8 Content-Disposition: inline In-Reply-To: <20160108194132.GA17464@jaegeuk.aosp> User-Agent: Mutt/1.5.23 (2014-03-12) X-Virus-Scanned: ClamAV using ClamSMTP Content-Transfer-Encoding: quoted-printable X-detected-operating-system: by eggs.gnu.org: GNU/Linux 3.x X-Received-From: 198.145.29.136 Cc: The development of GNU GRUB , linux-f2fs-devel@lists.sourceforge.net X-BeenThere: grub-devel@gnu.org X-Mailman-Version: 2.1.14 Precedence: list Reply-To: The development of GNU GRUB List-Id: The development of GNU GRUB List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , X-List-Received-Date: Mon, 22 Feb 2016 18:25:36 -0000 Chang log from v6: o remove redundant filesize check in ->read o check consistency in ->open regarding to inline_data -- >8 -- >From 51c120612fdbc4bc315e9c4c6e91ca888c3f3596 Mon Sep 17 00:00:00 2001 From: Jaegeuk Kim Date: Tue, 17 Nov 2015 12:45:13 -0800 Subject: [PATCH] F2FS support "F2FS (Flash-Friendly File System) is flash-friendly file system which wa= s merged into Linux kernel v3.8 in 2013. The motive for F2FS was to build a file system that from the start, takes= into account the characteristics of NAND flash memory-based storage devices (s= uch as solid-state disks, eMMC, and SD cards). F2FS was designed on a basis of a log-structured file system approach, wh= ich remedies some known issues of the older log structured file systems, such= as the snowball effect of wandering trees and high cleaning overhead. In add= ition, since a NAND-based storage device shows different characteristics accordi= ng to its internal geometry or flash memory management scheme (such as the Flas= h Translation Layer or FTL), it supports various parameters not only for configuring on-disk layout, but also for selecting allocation and cleanin= g algorithm.", quote by https://en.wikipedia.org/wiki/F2FS. The source codes for F2FS are available from: http://git.kernel.org/cgit/linux/kernel/git/jaegeuk/f2fs.git http://git.kernel.org/cgit/linux/kernel/git/jaegeuk/f2fs-tools.git Signed-off-by: Jaegeuk Kim --- Makefile.util.def | 7 + docs/grub.texi | 5 +- grub-core/Makefile.core.def | 5 + grub-core/fs/f2fs.c | 1289 ++++++++++++++++++++++++++++++++++++= ++++++ po/exclude.pot | 1 + tests/f2fs_test.in | 19 + tests/util/grub-fs-tester.in | 10 +- 7 files changed, 1332 insertions(+), 4 deletions(-) create mode 100644 grub-core/fs/f2fs.c create mode 100644 tests/f2fs_test.in diff --git a/Makefile.util.def b/Makefile.util.def index db7e8ec..84627bb 100644 --- a/Makefile.util.def +++ b/Makefile.util.def @@ -99,6 +99,7 @@ library =3D { common =3D grub-core/fs/ext2.c; common =3D grub-core/fs/fat.c; common =3D grub-core/fs/exfat.c; + common =3D grub-core/fs/f2fs.c; common =3D grub-core/fs/fshelp.c; common =3D grub-core/fs/hfs.c; common =3D grub-core/fs/hfsplus.c; @@ -766,6 +767,12 @@ script =3D { =20 script =3D { testcase; + name =3D f2fs_test; + common =3D tests/f2fs_test.in; +}; + +script =3D { + testcase; name =3D nilfs2_test; common =3D tests/nilfs2_test.in; }; diff --git a/docs/grub.texi b/docs/grub.texi index 1df3db2..e5a80f3 100644 --- a/docs/grub.texi +++ b/docs/grub.texi @@ -360,7 +360,8 @@ blocklist notation. The currently supported filesyste= m types are @dfn{Amiga Fast FileSystem (AFFS)}, @dfn{AtheOS fs}, @dfn{BeFS}, @dfn{BtrFS} (including raid0, raid1, raid10, gzip and lzo), @dfn{cpio} (little- and big-endian bin, odc and newc variants), -@dfn{Linux ext2/ext3/ext4}, @dfn{DOS FAT12/FAT16/FAT32}, @dfn{exFAT}, @d= fn{HFS}, +@dfn{Linux ext2/ext3/ext4}, @dfn{DOS FAT12/FAT16/FAT32}, @dfn{exFAT}, +@dfn{f2fs}, @dfn{HFS}, @dfn{HFS+}, @dfn{ISO9660} (including Joliet, Rock-ridge and multi-chunk = files), @dfn{JFS}, @dfn{Minix fs} (versions 1, 2 and 3), @dfn{nilfs2}, @dfn{NTFS} (including compression), @dfn{ReiserFS}, @dfn{ROMFS}, @@ -5347,7 +5348,7 @@ NTFS, JFS, UDF, HFS+, exFAT, long filenames in FAT,= Joliet part of ISO9660 are treated as UTF-16 as per specification. AFS and BFS are read as UTF-8, again according to specification. BtrFS, cpio, tar, squash4, m= inix, minix2, minix3, ROMFS, ReiserFS, XFS, ext2, ext3, ext4, FAT (short names= ), -RockRidge part of ISO9660, nilfs2, UFS1, UFS2 and ZFS are assumed +f2fs, RockRidge part of ISO9660, nilfs2, UFS1, UFS2 and ZFS are assumed to be UTF-8. This might be false on systems configured with legacy chars= et but as long as the charset used is superset of ASCII you should be able = to access ASCII-named files. And it's recommended to configure your system = to use diff --git a/grub-core/Makefile.core.def b/grub-core/Makefile.core.def index d9fa0e3..b585ade 100644 --- a/grub-core/Makefile.core.def +++ b/grub-core/Makefile.core.def @@ -1278,6 +1278,11 @@ module =3D { }; =20 module =3D { + name =3D f2fs; + common =3D fs/f2fs.c; +}; + +module =3D { name =3D fshelp; common =3D fs/fshelp.c; }; diff --git a/grub-core/fs/f2fs.c b/grub-core/fs/f2fs.c new file mode 100644 index 0000000..cb312b3 --- /dev/null +++ b/grub-core/fs/f2fs.c @@ -0,0 +1,1289 @@ +/* + * f2fs.c - Flash-Friendly File System + * + * Written by Jaegeuk Kim + * + * Copyright (C) 2015 Free Software Foundation, Inc. + * + * GRUB 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. + * + * GRUB 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 GRUB. If not, see . + */ +#include +#include +#include +#include +#include +#include +#include +#include +#include + +GRUB_MOD_LICENSE ("GPLv3+"); + +/* F2FS Magic Number */ +#define F2FS_SUPER_MAGIC 0xF2F52010 +#define CHECKSUM_OFFSET 4092 /* must be aligned 4 bytes */ +#define U32_CHECKSUM_OFFSET (CHECKSUM_OFFSET >> 2) + +/* byte-size offset */ +#define F2FS_SUPER_OFFSET ((grub_disk_addr_t)1024) +#define F2FS_SUPER_OFFSET0 (F2FS_SUPER_OFFSET >> GRUB_DISK_SECTOR_BITS) +#define F2FS_SUPER_OFFSET1 ((F2FS_SUPER_OFFSET + F2FS_BLKSIZE) >> \ + GRUB_DISK_SECTOR_BITS) + +/* 9 bits for 512 bytes */ +#define F2FS_MIN_LOG_SECTOR_SIZE 9 + +/* support only 4KB block */ +#define F2FS_BLK_BITS 12 +#define F2FS_BLKSIZE (1 << F2FS_BLK_BITS) +#define F2FS_BLK_SEC_BITS (F2FS_BLK_BITS - GRUB_DISK_SECTOR_BITS) + +#define VERSION_LEN 256 +#define F2FS_MAX_EXTENSION 64 + +#define CP_COMPACT_SUM_FLAG 0x00000004 +#define CP_UMOUNT_FLAG 0x00000001 + +#define MAX_ACTIVE_LOGS 16 +#define MAX_ACTIVE_NODE_LOGS 8 +#define MAX_ACTIVE_DATA_LOGS 8 +#define NR_CURSEG_DATA_TYPE 3 +#define NR_CURSEG_NODE_TYPE 3 +#define NR_CURSEG_TYPE (NR_CURSEG_DATA_TYPE + NR_CURSEG_NODE_TYPE) + +#define ENTRIES_IN_SUM 512 +#define SUMMARY_SIZE 7 +#define SUM_FOOTER_SIZE 5 +#define JENTRY_SIZE (sizeof(struct grub_f2fs_nat_jent)) +#define SUM_ENTRIES_SIZE (SUMMARY_SIZE * ENTRIES_IN_SUM) +#define SUM_JOURNAL_SIZE (F2FS_BLKSIZE - SUM_FOOTER_SIZE -\ + SUM_ENTRIES_SIZE) +#define NAT_JOURNAL_ENTRIES ((SUM_JOURNAL_SIZE - 2) / JENTRY_SIZE) +#define NAT_JOURNAL_RESERVED ((SUM_JOURNAL_SIZE - 2) % JENTRY_SIZE) + +#define NAT_ENTRY_SIZE (sizeof(struct grub_f2fs_nat_entry)) +#define NAT_ENTRY_PER_BLOCK (F2FS_BLKSIZE / NAT_ENTRY_SIZE) + +#define F2FS_NAME_LEN 255 +#define F2FS_SLOT_LEN 8 +#define NR_DENTRY_IN_BLOCK 214 +#define SIZE_OF_DIR_ENTRY 11 /* by byte */ +#define BITS_PER_BYTE 8 +#define SIZE_OF_DENTRY_BITMAP ((NR_DENTRY_IN_BLOCK + BITS_PER_BYTE - 1) = / \ + BITS_PER_BYTE) +#define SIZE_OF_RESERVED (F2FS_BLKSIZE - ((SIZE_OF_DIR_ENTRY + \ + F2FS_SLOT_LEN) * \ + NR_DENTRY_IN_BLOCK + SIZE_OF_DENTRY_BITMAP)) + +#define F2FS_INLINE_XATTR_ADDRS 50 /* 200 bytes for inline xattrs */ +#define DEF_ADDRS_PER_INODE 923 /* Address Pointers in an Inode */ + +#define ADDRS_PER_BLOCK 1018 /* Address Pointers in a Direct Block */ +#define NIDS_PER_BLOCK 1018 /* Node IDs in an Indirect Block */ +#define NODE_DIR1_BLOCK (DEF_ADDRS_PER_INODE + 1) +#define NODE_DIR2_BLOCK (DEF_ADDRS_PER_INODE + 2) +#define NODE_IND1_BLOCK (DEF_ADDRS_PER_INODE + 3) +#define NODE_IND2_BLOCK (DEF_ADDRS_PER_INODE + 4) +#define NODE_DIND_BLOCK (DEF_ADDRS_PER_INODE + 5) + +#define MAX_INLINE_DATA (4 * (DEF_ADDRS_PER_INODE - \ + F2FS_INLINE_XATTR_ADDRS - 1)) +#define NR_INLINE_DENTRY (MAX_INLINE_DATA * BITS_PER_BYTE / \ + ((SIZE_OF_DIR_ENTRY + F2FS_SLOT_LEN) * \ + BITS_PER_BYTE + 1)) +#define INLINE_DENTRY_BITMAP_SIZE ((NR_INLINE_DENTRY + \ + BITS_PER_BYTE - 1) / BITS_PER_BYTE) +#define INLINE_RESERVED_SIZE (MAX_INLINE_DATA - \ + ((SIZE_OF_DIR_ENTRY + F2FS_SLOT_LEN) * \ + NR_INLINE_DENTRY + INLINE_DENTRY_BITMAP_SIZE)) +#define CURSEG_HOT_DATA 0 + +#define CKPT_FLAG_SET(ckpt, f) \ + (ckpt)->ckpt_flags & grub_cpu_to_le32_compile_time (f) + +#define F2FS_INLINE_XATTR 0x01 /* file inline xattr flag */ +#define F2FS_INLINE_DATA 0x02 /* file inline data flag */ +#define F2FS_INLINE_DENTRY 0x04 /* file inline dentry flag */ +#define F2FS_DATA_EXIST 0x08 /* file inline data exist flag */ +#define F2FS_INLINE_DOTS 0x10 /* file having implicit dot dentries */ + +enum FILE_TYPE +{ + F2FS_FT_UNKNOWN, + F2FS_FT_REG_FILE =3D 1, + F2FS_FT_DIR =3D 2, + F2FS_FT_SYMLINK =3D 7, +}; + +#define MAX_VOLUME_NAME 512 + +struct grub_f2fs_superblock +{ + grub_uint32_t magic; + grub_uint16_t dummy1[2]; + grub_uint32_t log_sectorsize; + grub_uint32_t log_sectors_per_block; + grub_uint32_t log_blocksize; + grub_uint32_t log_blocks_per_seg; + grub_uint32_t segs_per_sec; + grub_uint32_t secs_per_zone; + grub_uint32_t checksum_offset; + grub_uint8_t dummy2[40]; + grub_uint32_t cp_blkaddr; + grub_uint32_t sit_blkaddr; + grub_uint32_t nat_blkaddr; + grub_uint32_t ssa_blkaddr; + grub_uint32_t main_blkaddr; + grub_uint32_t root_ino; + grub_uint32_t node_ino; + grub_uint32_t meta_ino; + grub_uint8_t uuid[16]; + grub_uint16_t volume_name[MAX_VOLUME_NAME]; + grub_uint32_t extension_count; + grub_uint8_t extension_list[F2FS_MAX_EXTENSION][8]; + grub_uint32_t cp_payload; + grub_uint8_t version[VERSION_LEN]; + grub_uint8_t init_version[VERSION_LEN]; +} GRUB_PACKED; + +struct grub_f2fs_checkpoint +{ + grub_uint64_t checkpoint_ver; + grub_uint64_t user_block_count; + grub_uint64_t valid_block_count; + grub_uint32_t rsvd_segment_count; + grub_uint32_t overprov_segment_count; + grub_uint32_t free_segment_count; + grub_uint32_t cur_node_segno[MAX_ACTIVE_NODE_LOGS]; + grub_uint16_t cur_node_blkoff[MAX_ACTIVE_NODE_LOGS]; + grub_uint32_t cur_data_segno[MAX_ACTIVE_DATA_LOGS]; + grub_uint16_t cur_data_blkoff[MAX_ACTIVE_DATA_LOGS]; + grub_uint32_t ckpt_flags; + grub_uint32_t cp_pack_total_block_count; + grub_uint32_t cp_pack_start_sum; + grub_uint32_t valid_node_count; + grub_uint32_t valid_inode_count; + grub_uint32_t next_free_nid; + grub_uint32_t sit_ver_bitmap_bytesize; + grub_uint32_t nat_ver_bitmap_bytesize; + grub_uint32_t checksum_offset; + grub_uint64_t elapsed_time; + grub_uint8_t alloc_type[MAX_ACTIVE_LOGS]; + grub_uint8_t sit_nat_version_bitmap[3900]; + grub_uint32_t checksum; +} GRUB_PACKED; + +struct grub_f2fs_nat_entry { + grub_uint8_t version; + grub_uint32_t ino; + grub_uint32_t block_addr; +} GRUB_PACKED; + +struct grub_f2fs_nat_jent +{ + grub_uint32_t nid; + struct grub_f2fs_nat_entry ne; +} GRUB_PACKED; + +struct grub_f2fs_nat_journal { + grub_uint16_t n_nats; + struct grub_f2fs_nat_jent entries[NAT_JOURNAL_ENTRIES]; + grub_uint8_t reserved[NAT_JOURNAL_RESERVED]; +} GRUB_PACKED; + +struct grub_f2fs_nat_block { + struct grub_f2fs_nat_entry ne[NAT_ENTRY_PER_BLOCK]; +} GRUB_PACKED; + +struct grub_f2fs_dir_entry +{ + grub_uint32_t hash_code; + grub_uint32_t ino; + grub_uint16_t name_len; + grub_uint8_t file_type; +} GRUB_PACKED; + +struct grub_f2fs_inline_dentry +{ + grub_uint8_t dentry_bitmap[INLINE_DENTRY_BITMAP_SIZE]; + grub_uint8_t reserved[INLINE_RESERVED_SIZE]; + struct grub_f2fs_dir_entry dentry[NR_INLINE_DENTRY]; + grub_uint8_t filename[NR_INLINE_DENTRY][F2FS_SLOT_LEN]; +} GRUB_PACKED; + +struct grub_f2fs_dentry_block { + grub_uint8_t dentry_bitmap[SIZE_OF_DENTRY_BITMAP]; + grub_uint8_t reserved[SIZE_OF_RESERVED]; + struct grub_f2fs_dir_entry dentry[NR_DENTRY_IN_BLOCK]; + grub_uint8_t filename[NR_DENTRY_IN_BLOCK][F2FS_SLOT_LEN]; +} GRUB_PACKED; + +struct grub_f2fs_inode +{ + grub_uint16_t i_mode; + grub_uint8_t i_advise; + grub_uint8_t i_inline; + grub_uint32_t i_uid; + grub_uint32_t i_gid; + grub_uint32_t i_links; + grub_uint64_t i_size; + grub_uint64_t i_blocks; + grub_uint64_t i_atime; + grub_uint64_t i_ctime; + grub_uint64_t i_mtime; + grub_uint32_t i_atime_nsec; + grub_uint32_t i_ctime_nsec; + grub_uint32_t i_mtime_nsec; + grub_uint32_t i_generation; + grub_uint32_t i_current_depth; + grub_uint32_t i_xattr_nid; + grub_uint32_t i_flags; + grub_uint32_t i_pino; + grub_uint32_t i_namelen; + grub_uint8_t i_name[F2FS_NAME_LEN]; + grub_uint8_t i_dir_level; + grub_uint8_t i_ext[12]; + grub_uint32_t i_addr[DEF_ADDRS_PER_INODE]; + grub_uint32_t i_nid[5]; +} GRUB_PACKED; + +struct grub_direct_node { + grub_uint32_t addr[ADDRS_PER_BLOCK]; +} GRUB_PACKED; + +struct grub_indirect_node { + grub_uint32_t nid[NIDS_PER_BLOCK]; +} GRUB_PACKED; + +struct grub_f2fs_node +{ + union + { + struct grub_f2fs_inode i; + struct grub_direct_node dn; + struct grub_indirect_node in; + char buf[F2FS_BLKSIZE - 40]; /* Should occupy F2FS_BLKSIZE totally *= / + }; + grub_uint8_t dummy[40]; +} GRUB_PACKED; + +struct grub_fshelp_node +{ + struct grub_f2fs_data *data; + struct grub_f2fs_node inode; + grub_uint32_t ino; + int inode_read; +}; + +struct grub_f2fs_data +{ + struct grub_f2fs_superblock sblock; + struct grub_f2fs_checkpoint ckpt; + + grub_uint32_t root_ino; + grub_uint32_t blocks_per_seg; + grub_uint32_t cp_blkaddr; + grub_uint32_t nat_blkaddr; + + struct grub_f2fs_nat_journal nat_j; + char *nat_bitmap; + + grub_disk_t disk; + struct grub_f2fs_node *inode; + struct grub_fshelp_node diropen; +}; + +struct grub_f2fs_dir_iter_ctx +{ + struct grub_f2fs_data *data; + grub_fshelp_iterate_dir_hook_t hook; + void *hook_data; + grub_uint8_t *bitmap; + grub_uint8_t (*filename)[F2FS_SLOT_LEN]; + struct grub_f2fs_dir_entry *dentry; + int max; +}; + +struct grub_f2fs_dir_ctx +{ + grub_fs_dir_hook_t hook; + void *hook_data; + struct grub_f2fs_data *data; +}; + +static grub_dl_t my_mod; + +static inline int +grub_f2fs_test_bit_le (int nr, const grub_uint8_t *addr) +{ + return addr[nr >> 3] & (1 << (nr & 7)); +} + +static inline char * +__inline_addr (struct grub_f2fs_inode *inode) +{ + return (char *)&inode->i_addr[1]; +} + +static inline grub_uint64_t +grub_f2fs_file_size (struct grub_f2fs_inode *inode) +{ + return grub_le_to_cpu64 (inode->i_size); +} + +static inline grub_uint32_t +__start_cp_addr (struct grub_f2fs_data *data) +{ + struct grub_f2fs_checkpoint *ckpt =3D &data->ckpt; + grub_uint32_t start_addr =3D data->cp_blkaddr; + + if (!(ckpt->checkpoint_ver & grub_cpu_to_le64_compile_time(1))) + return start_addr + data->blocks_per_seg; + return start_addr; +} + +static inline grub_uint32_t +__start_sum_block (struct grub_f2fs_data *data) +{ + struct grub_f2fs_checkpoint *ckpt =3D &data->ckpt; + + return __start_cp_addr (data) + grub_le_to_cpu32 (ckpt->cp_pack_start_= sum); +} + +static inline grub_uint32_t +__sum_blk_addr (struct grub_f2fs_data *data, int base, int type) +{ + struct grub_f2fs_checkpoint *ckpt =3D &data->ckpt; + + return __start_cp_addr (data) + + grub_le_to_cpu32 (ckpt->cp_pack_total_block_count) + - (base + 1) + type; +} + +static inline void * +__nat_bitmap_ptr (struct grub_f2fs_data *data) +{ + struct grub_f2fs_checkpoint *ckpt =3D &data->ckpt; + grub_uint32_t offset; + + if (grub_le_to_cpu32 (data->sblock.cp_payload) > 0) + return ckpt->sit_nat_version_bitmap; + + offset =3D grub_le_to_cpu32 (ckpt->sit_ver_bitmap_bytesize); + return ckpt->sit_nat_version_bitmap + offset; +} + +static inline grub_uint32_t +__get_node_id (struct grub_f2fs_node *rn, int off, int inode_block) +{ + if (inode_block) + return grub_le_to_cpu32 (rn->i.i_nid[off - NODE_DIR1_BLOCK]); + return grub_le_to_cpu32 (rn->in.nid[off]); +} + +static inline grub_err_t +grub_f2fs_block_read (struct grub_f2fs_data *data, grub_uint32_t blkaddr= , void *buf) +{ + return grub_disk_read (data->disk, + ((grub_disk_addr_t)blkaddr) << F2FS_BLK_SEC_BITS, + 0, F2FS_BLKSIZE, buf); +} + +/* + * CRC32 +*/ +#define CRCPOLY_LE 0xedb88320 + +static inline grub_uint32_t +grub_f2fs_cal_crc32 (const void *buf, const grub_uint32_t len) +{ + grub_uint32_t crc =3D F2FS_SUPER_MAGIC; + unsigned char *p =3D (unsigned char *)buf; + grub_uint32_t tmp =3D len; + int i; + + while (tmp--) + { + crc ^=3D *p++; + for (i =3D 0; i < 8; i++) + crc =3D (crc >> 1) ^ ((crc & 1) ? CRCPOLY_LE : 0); + } + return crc; +} + +static inline int +grub_f2fs_crc_valid (grub_uint32_t blk_crc, void *buf, const grub_uint32= _t len) +{ + grub_uint32_t cal_crc =3D 0; + + cal_crc =3D grub_f2fs_cal_crc32 (buf, len); + + return (cal_crc =3D=3D blk_crc) ? 1 : 0; +} + +static inline int +grub_f2fs_test_bit (grub_uint32_t nr, const char *p) +{ + int mask; + + p +=3D (nr >> 3); + mask =3D 1 << (7 - (nr & 0x07)); + return mask & *p; +} + +static int +grub_f2fs_sanity_check_sb (struct grub_f2fs_superblock *sb) +{ + grub_uint32_t log_sectorsize, log_sectors_per_block; + + if (sb->magic !=3D grub_cpu_to_le32_compile_time (F2FS_SUPER_MAGIC)) + return -1; + + if (sb->log_blocksize !=3D grub_cpu_to_le32_compile_time (F2FS_BLK_BIT= S)) + return -1; + + log_sectorsize =3D grub_le_to_cpu32 (sb->log_sectorsize); + log_sectors_per_block =3D grub_le_to_cpu32 (sb->log_sectors_per_block)= ; + + if (log_sectorsize > F2FS_BLK_BITS) + return -1; + + if (log_sectorsize < F2FS_MIN_LOG_SECTOR_SIZE) + return -1; + + if (log_sectors_per_block + log_sectorsize !=3D F2FS_BLK_BITS) + return -1; + + return 0; +} + +static int +grub_f2fs_read_sb (struct grub_f2fs_data *data, grub_disk_addr_t offset) +{ + grub_disk_t disk =3D data->disk; + grub_err_t err; + + /* Read first super block. */ + err =3D grub_disk_read (disk, offset, 0, sizeof (data->sblock), &data-= >sblock); + if (err) + return -1; + + return grub_f2fs_sanity_check_sb (&data->sblock); +} + +static void * +validate_checkpoint (struct grub_f2fs_data *data, grub_uint32_t cp_addr, + grub_uint64_t *version) +{ + grub_uint32_t *cp_page_1, *cp_page_2; + struct grub_f2fs_checkpoint *cp_block; + grub_uint64_t cur_version =3D 0, pre_version =3D 0; + grub_uint32_t crc =3D 0; + grub_uint32_t crc_offset; + grub_err_t err; + + /* Read the 1st cp block in this CP pack */ + cp_page_1 =3D grub_malloc (F2FS_BLKSIZE); + if (!cp_page_1) + return NULL; + + err =3D grub_f2fs_block_read (data, cp_addr, cp_page_1); + if (err) + goto invalid_cp1; + + cp_block =3D (struct grub_f2fs_checkpoint *)cp_page_1; + crc_offset =3D grub_le_to_cpu32 (cp_block->checksum_offset); + if (crc_offset !=3D CHECKSUM_OFFSET) + goto invalid_cp1; + + crc =3D grub_le_to_cpu32 (*(cp_page_1 + U32_CHECKSUM_OFFSET)); + if (!grub_f2fs_crc_valid (crc, cp_block, crc_offset)) + goto invalid_cp1; + + pre_version =3D grub_le_to_cpu64 (cp_block->checkpoint_ver); + + /* Read the 2nd cp block in this CP pack */ + cp_page_2 =3D grub_malloc (F2FS_BLKSIZE); + if (!cp_page_2) + goto invalid_cp1; + + cp_addr +=3D grub_le_to_cpu32 (cp_block->cp_pack_total_block_count) - = 1; + + err =3D grub_f2fs_block_read (data, cp_addr, cp_page_2); + if (err) + goto invalid_cp2; + + cp_block =3D (struct grub_f2fs_checkpoint *)cp_page_2; + crc_offset =3D grub_le_to_cpu32 (cp_block->checksum_offset); + if (crc_offset !=3D CHECKSUM_OFFSET) + goto invalid_cp2; + + crc =3D grub_le_to_cpu32 (*(cp_page_2 + U32_CHECKSUM_OFFSET)); + if (!grub_f2fs_crc_valid (crc, cp_block, crc_offset)) + goto invalid_cp2; + + cur_version =3D grub_le_to_cpu64 (cp_block->checkpoint_ver); + if (cur_version =3D=3D pre_version) + { + *version =3D cur_version; + grub_free (cp_page_2); + return cp_page_1; + } + +invalid_cp2: + grub_free (cp_page_2); +invalid_cp1: + grub_free (cp_page_1); + return NULL; +} + +static grub_err_t +grub_f2fs_read_cp (struct grub_f2fs_data *data) +{ + void *cp1, *cp2, *cur_page; + grub_uint64_t cp1_version =3D 0, cp2_version =3D 0; + grub_uint64_t cp_start_blk_no; + + /* + * Finding out valid cp block involves read both + * sets (cp pack1 and cp pack 2) + */ + cp_start_blk_no =3D data->cp_blkaddr; + cp1 =3D validate_checkpoint (data, cp_start_blk_no, &cp1_version); + if (!cp1 && grub_errno) + return grub_errno; + + /* The second checkpoint pack should start at the next segment */ + cp_start_blk_no +=3D data->blocks_per_seg; + cp2 =3D validate_checkpoint (data, cp_start_blk_no, &cp2_version); + if (!cp2 && grub_errno) + { + grub_free (cp1); + return grub_errno; + } + + if (cp1 && cp2) + cur_page =3D (cp2_version > cp1_version) ? cp2 : cp1; + else if (cp1) + cur_page =3D cp1; + else if (cp2) + cur_page =3D cp2; + else + return grub_error (GRUB_ERR_BAD_FS, "no checkpoints"); + + grub_memcpy (&data->ckpt, cur_page, F2FS_BLKSIZE); + + grub_free (cp1); + grub_free (cp2); + return 0; +} + +static grub_err_t +get_nat_journal (struct grub_f2fs_data *data) +{ + grub_uint32_t block; + char *buf; + grub_err_t err; + + buf =3D grub_malloc (F2FS_BLKSIZE); + if (!buf) + return grub_errno; + + if (CKPT_FLAG_SET(&data->ckpt, CP_COMPACT_SUM_FLAG)) + block =3D __start_sum_block (data); + else if (CKPT_FLAG_SET (&data->ckpt, CP_UMOUNT_FLAG)) + block =3D __sum_blk_addr (data, NR_CURSEG_TYPE, CURSEG_HOT_DATA); + else + block =3D __sum_blk_addr (data, NR_CURSEG_DATA_TYPE, CURSEG_HOT_DATA= ); + + err =3D grub_f2fs_block_read (data, block, buf); + if (err) + goto fail; + + if (CKPT_FLAG_SET (&data->ckpt, CP_COMPACT_SUM_FLAG)) + grub_memcpy (&data->nat_j, buf, SUM_JOURNAL_SIZE); + else + grub_memcpy (&data->nat_j, buf + SUM_ENTRIES_SIZE, SUM_JOURNAL_SIZE)= ; + +fail: + grub_free (buf); + return err; +} + +static grub_uint32_t +get_blkaddr_from_nat_journal (struct grub_f2fs_data *data, grub_uint32_t= nid) +{ + grub_uint16_t n =3D grub_le_to_cpu16 (data->nat_j.n_nats); + grub_uint32_t blkaddr =3D 0; + grub_uint16_t i; + + for (i =3D 0; i < n; i++) + { + if (grub_le_to_cpu32 (data->nat_j.entries[i].nid) =3D=3D nid) + { + blkaddr =3D grub_le_to_cpu32 (data->nat_j.entries[i].ne.block_= addr); + break; + } + } + return blkaddr; +} + +static grub_uint32_t +get_node_blkaddr (struct grub_f2fs_data *data, grub_uint32_t nid) +{ + struct grub_f2fs_nat_block *nat_block; + grub_uint32_t seg_off, block_off, entry_off, block_addr; + grub_uint32_t blkaddr; + grub_err_t err; + + blkaddr =3D get_blkaddr_from_nat_journal (data, nid); + if (blkaddr) + return blkaddr; + + nat_block =3D grub_malloc (F2FS_BLKSIZE); + if (!nat_block) + return 0; + + block_off =3D nid / NAT_ENTRY_PER_BLOCK; + entry_off =3D nid % NAT_ENTRY_PER_BLOCK; + + seg_off =3D block_off / data->blocks_per_seg; + block_addr =3D data->nat_blkaddr + + ((seg_off * data->blocks_per_seg) << 1) + + (block_off & (data->blocks_per_seg - 1)); + + if (grub_f2fs_test_bit (block_off, data->nat_bitmap)) + block_addr +=3D data->blocks_per_seg; + + err =3D grub_f2fs_block_read (data, block_addr, nat_block); + if (err) + { + grub_free (nat_block); + return 0; + } + + blkaddr =3D grub_le_to_cpu32 (nat_block->ne[entry_off].block_addr); + + grub_free (nat_block); + + return blkaddr; +} + +static int +grub_get_node_path (struct grub_f2fs_inode *inode, grub_uint32_t block, + grub_uint32_t offset[4], grub_uint32_t noffset[4]) +{ + grub_uint32_t direct_blks =3D ADDRS_PER_BLOCK; + grub_uint32_t dptrs_per_blk =3D NIDS_PER_BLOCK; + grub_uint32_t indirect_blks =3D ADDRS_PER_BLOCK * NIDS_PER_BLOCK; + grub_uint32_t dindirect_blks =3D indirect_blks * NIDS_PER_BLOCK; + grub_uint32_t direct_index =3D DEF_ADDRS_PER_INODE; + int n =3D 0; + int level =3D 0; + + if (inode->i_inline & F2FS_INLINE_XATTR) + direct_index -=3D F2FS_INLINE_XATTR_ADDRS; + + noffset[0] =3D 0; + + if (block < direct_index) + { + offset[n] =3D block; + goto got; + } + + block -=3D direct_index; + if (block < direct_blks) + { + offset[n++] =3D NODE_DIR1_BLOCK; + noffset[n] =3D 1; + offset[n] =3D block; + level =3D 1; + goto got; + } + + block -=3D direct_blks; + if (block < direct_blks) + { + offset[n++] =3D NODE_DIR2_BLOCK; + noffset[n] =3D 2; + offset[n] =3D block; + level =3D 1; + goto got; + } + + block -=3D direct_blks; + if (block < indirect_blks) + { + offset[n++] =3D NODE_IND1_BLOCK; + noffset[n] =3D 3; + offset[n++] =3D block / direct_blks; + noffset[n] =3D 4 + offset[n - 1]; + offset[n] =3D block % direct_blks; + level =3D 2; + goto got; + } + + block -=3D indirect_blks; + if (block < indirect_blks) + { + offset[n++] =3D NODE_IND2_BLOCK; + noffset[n] =3D 4 + dptrs_per_blk; + offset[n++] =3D block / direct_blks; + noffset[n] =3D 5 + dptrs_per_blk + offset[n - 1]; + offset[n] =3D block % direct_blks; + level =3D 2; + goto got; + } + + block -=3D indirect_blks; + if (block < dindirect_blks) + { + offset[n++] =3D NODE_DIND_BLOCK; + noffset[n] =3D 5 + (dptrs_per_blk * 2); + offset[n++] =3D block / indirect_blks; + noffset[n] =3D 6 + (dptrs_per_blk * 2) + + offset[n - 1] * (dptrs_per_blk + 1); + offset[n++] =3D (block / direct_blks) % dptrs_per_blk; + noffset[n] =3D 7 + (dptrs_per_blk * 2) + + offset[n - 2] * (dptrs_per_blk + 1) + offset[n - 1]; + offset[n] =3D block % direct_blks; + level =3D 3; + goto got; + } +got: + return level; +} + +static grub_err_t +grub_f2fs_read_node (struct grub_f2fs_data *data, + grub_uint32_t nid, struct grub_f2fs_node *np) +{ + grub_uint32_t blkaddr; + + blkaddr =3D get_node_blkaddr (data, nid); + if (!blkaddr) + return grub_errno; + + return grub_f2fs_block_read (data, blkaddr, np); +} + +static struct grub_f2fs_data * +grub_f2fs_mount (grub_disk_t disk) +{ + struct grub_f2fs_data *data; + grub_err_t err; + + data =3D grub_malloc (sizeof (*data)); + if (!data) + return NULL; + + data->disk =3D disk; + + if (grub_f2fs_read_sb (data, F2FS_SUPER_OFFSET0)) + { + if (grub_f2fs_read_sb (data, F2FS_SUPER_OFFSET1)) + { + if (grub_errno =3D=3D GRUB_ERR_NONE) + grub_error (GRUB_ERR_BAD_FS, + "not a F2FS filesystem (no superblock)"); + goto fail; + } + } + + data->root_ino =3D grub_le_to_cpu32 (data->sblock.root_ino); + data->cp_blkaddr =3D grub_le_to_cpu32 (data->sblock.cp_blkaddr); + data->nat_blkaddr =3D grub_le_to_cpu32 (data->sblock.nat_blkaddr); + data->blocks_per_seg =3D 1 << + grub_le_to_cpu32 (data->sblock.log_blocks_per_seg); + + err =3D grub_f2fs_read_cp (data); + if (err) + goto fail; + + data->nat_bitmap =3D __nat_bitmap_ptr (data); + + err =3D get_nat_journal (data); + if (err) + goto fail; + + data->diropen.data =3D data; + data->diropen.ino =3D data->root_ino; + data->diropen.inode_read =3D 1; + data->inode =3D &data->diropen.inode; + + err =3D grub_f2fs_read_node (data, data->root_ino, data->inode); + if (err) + goto fail; + + return data; + +fail: + grub_free (data); + return NULL; +} + +/* guarantee inline_data was handled by caller */ +static grub_disk_addr_t +grub_f2fs_get_block (grub_fshelp_node_t node, grub_disk_addr_t block_ofs= ) +{ + struct grub_f2fs_data *data =3D node->data; + struct grub_f2fs_inode *inode =3D &node->inode.i; + grub_uint32_t offset[4], noffset[4], nids[4]; + struct grub_f2fs_node *node_block; + grub_uint32_t block_addr =3D -1; + int level, i; + + level =3D grub_get_node_path (inode, block_ofs, offset, noffset); + if (level =3D=3D 0) + return grub_le_to_cpu32 (inode->i_addr[offset[0]]); + + node_block =3D grub_malloc (F2FS_BLKSIZE); + if (!node_block) + return -1; + + nids[1] =3D __get_node_id (&node->inode, offset[0], 1); + + /* get indirect or direct nodes */ + for (i =3D 1; i <=3D level; i++) + { + grub_f2fs_read_node (data, nids[i], node_block); + if (grub_errno) + goto fail; + + if (i < level) + nids[i + 1] =3D __get_node_id (node_block, offset[i], 0); + } + + block_addr =3D grub_le_to_cpu32 (node_block->dn.addr[offset[level]]); +fail: + grub_free (node_block); + return block_addr; +} + +static grub_ssize_t +grub_f2fs_read_file (grub_fshelp_node_t node, + grub_disk_read_hook_t read_hook, void *read_hook_data, + grub_off_t pos, grub_size_t len, char *buf) +{ + struct grub_f2fs_inode *inode =3D &node->inode.i; + grub_off_t filesize =3D grub_f2fs_file_size (inode); + char *inline_addr =3D __inline_addr (inode); + + if (inode->i_inline & F2FS_INLINE_DATA) + { + if (filesize > MAX_INLINE_DATA) + return -1; + if (len > filesize - pos) + len =3D filesize - pos; + + grub_memcpy (buf + pos, inline_addr + pos, len); + return len; + } + + return grub_fshelp_read_file (node->data->disk, node, + read_hook, read_hook_data, + pos, len, buf, grub_f2fs_get_block, + filesize, + F2FS_BLK_SEC_BITS, 0); +} + +static char * +grub_f2fs_read_symlink (grub_fshelp_node_t node) +{ + char *symlink; + struct grub_fshelp_node *diro =3D node; + grub_uint64_t filesize; + + if (!diro->inode_read) + { + grub_f2fs_read_node (diro->data, diro->ino, &diro->inode); + if (grub_errno) + return 0; + } + + filesize =3D grub_f2fs_file_size(&diro->inode.i); + + symlink =3D grub_malloc (filesize + 1); + if (!symlink) + return 0; + + grub_f2fs_read_file (diro, 0, 0, 0, filesize, symlink); + if (grub_errno) + { + grub_free (symlink); + return 0; + } + + symlink[filesize] =3D '\0'; + return symlink; +} + +static int +grub_f2fs_check_dentries (struct grub_f2fs_dir_iter_ctx *ctx) +{ + struct grub_fshelp_node *fdiro; + int i; + + for (i =3D 0; i < ctx->max;) + { + char *filename; + enum grub_fshelp_filetype type =3D GRUB_FSHELP_UNKNOWN; + enum FILE_TYPE ftype; + int name_len; + int ret; + + if (grub_f2fs_test_bit_le (i, ctx->bitmap) =3D=3D 0) + { + i++; + continue; + } + + ftype =3D ctx->dentry[i].file_type; + name_len =3D grub_le_to_cpu16 (ctx->dentry[i].name_len); + filename =3D grub_malloc (name_len + 1); + if (!filename) + return 0; + + grub_memcpy (filename, ctx->filename[i], name_len); + filename[name_len] =3D 0; + + fdiro =3D grub_malloc (sizeof (struct grub_fshelp_node)); + if (!fdiro) + { + grub_free(filename); + return 0; + } + + if (ftype =3D=3D F2FS_FT_DIR) + type =3D GRUB_FSHELP_DIR; + else if (ftype =3D=3D F2FS_FT_SYMLINK) + type =3D GRUB_FSHELP_SYMLINK; + else if (ftype =3D=3D F2FS_FT_REG_FILE) + type =3D GRUB_FSHELP_REG; + + fdiro->data =3D ctx->data; + fdiro->ino =3D grub_le_to_cpu32 (ctx->dentry[i].ino); + fdiro->inode_read =3D 0; + + ret =3D ctx->hook (filename, type, fdiro, ctx->hook_data); + grub_free(filename); + if (ret) + return 1; + + i +=3D (name_len + F2FS_SLOT_LEN - 1) / F2FS_SLOT_LEN; + } + return 0; +} + +static int +grub_f2fs_iterate_inline_dir (struct grub_f2fs_inode *dir, + struct grub_f2fs_dir_iter_ctx *ctx) +{ + struct grub_f2fs_inline_dentry *de_blk; + + de_blk =3D (struct grub_f2fs_inline_dentry *) __inline_addr (dir); + + ctx->bitmap =3D de_blk->dentry_bitmap; + ctx->dentry =3D de_blk->dentry; + ctx->filename =3D de_blk->filename; + ctx->max =3D NR_INLINE_DENTRY; + + return grub_f2fs_check_dentries (ctx); +} + +static int +grub_f2fs_iterate_dir (grub_fshelp_node_t dir, + grub_fshelp_iterate_dir_hook_t hook, void *hook_data) +{ + struct grub_fshelp_node *diro =3D (struct grub_fshelp_node *) dir; + struct grub_f2fs_inode *inode; + struct grub_f2fs_dir_iter_ctx ctx =3D { + .data =3D diro->data, + .hook =3D hook, + .hook_data =3D hook_data + }; + grub_off_t fpos =3D 0; + + if (!diro->inode_read) + { + grub_f2fs_read_node (diro->data, diro->ino, &diro->inode); + if (grub_errno) + return 0; + } + + inode =3D &diro->inode.i; + + if (inode->i_inline & F2FS_INLINE_DENTRY) + return grub_f2fs_iterate_inline_dir (inode, &ctx); + + while (fpos < grub_f2fs_file_size (inode)) + { + struct grub_f2fs_dentry_block *de_blk; + char *buf; + int ret; + + buf =3D grub_zalloc (F2FS_BLKSIZE); + if (!buf) + return 0; + + grub_f2fs_read_file (diro, 0, 0, fpos, F2FS_BLKSIZE, buf); + if (grub_errno) + { + grub_free (buf); + return 0; + } + + de_blk =3D (struct grub_f2fs_dentry_block *) buf; + + ctx.bitmap =3D de_blk->dentry_bitmap; + ctx.dentry =3D de_blk->dentry; + ctx.filename =3D de_blk->filename; + ctx.max =3D NR_DENTRY_IN_BLOCK; + + ret =3D grub_f2fs_check_dentries (&ctx); + grub_free (buf); + if (ret) + return 1; + + fpos +=3D F2FS_BLKSIZE; + } + return 0; +} + +static int +grub_f2fs_dir_iter (const char *filename, enum grub_fshelp_filetype file= type, + grub_fshelp_node_t node, void *data) +{ + struct grub_f2fs_dir_ctx *ctx =3D data; + struct grub_dirhook_info info; + + grub_memset (&info, 0, sizeof (info)); + if (!node->inode_read) + { + grub_f2fs_read_node (ctx->data, node->ino, &node->inode); + if (!grub_errno) + node->inode_read =3D 1; + grub_errno =3D GRUB_ERR_NONE; + } + if (node->inode_read) + { + info.mtimeset =3D 1; + info.mtime =3D grub_le_to_cpu64 (node->inode.i.i_mtime); + } + + info.dir =3D ((filetype & GRUB_FSHELP_TYPE_MASK) =3D=3D GRUB_FSHELP_DI= R); + grub_free (node); + return ctx->hook (filename, &info, ctx->hook_data); +} + +static grub_err_t +grub_f2fs_dir (grub_device_t device, const char *path, + grub_fs_dir_hook_t hook, void *hook_data) +{ + struct grub_f2fs_dir_ctx ctx =3D { + .hook =3D hook, + .hook_data =3D hook_data + }; + struct grub_fshelp_node *fdiro =3D 0; + + grub_dl_ref (my_mod); + + ctx.data =3D grub_f2fs_mount (device->disk); + if (!ctx.data) + goto fail; + + grub_fshelp_find_file (path, &ctx.data->diropen, &fdiro, + grub_f2fs_iterate_dir, grub_f2fs_read_symlink, + GRUB_FSHELP_DIR); + if (grub_errno) + goto fail; + + grub_f2fs_iterate_dir (fdiro, grub_f2fs_dir_iter, &ctx); + +fail: + if (fdiro !=3D &ctx.data->diropen) + grub_free (fdiro); + grub_free (ctx.data); + grub_dl_unref (my_mod); + return grub_errno; +} + + +/* Open a file named NAME and initialize FILE. */ +static grub_err_t +grub_f2fs_open (struct grub_file *file, const char *name) +{ + struct grub_f2fs_data *data =3D NULL; + struct grub_fshelp_node *fdiro =3D 0; + struct grub_f2fs_inode *inode; + + grub_dl_ref (my_mod); + + data =3D grub_f2fs_mount (file->device->disk); + if (!data) + goto fail; + + grub_fshelp_find_file (name, &data->diropen, &fdiro, + grub_f2fs_iterate_dir, grub_f2fs_read_symlink, + GRUB_FSHELP_REG); + if (grub_errno) + goto fail; + + if (!fdiro->inode_read) + { + grub_f2fs_read_node (data, fdiro->ino, &fdiro->inode); + if (grub_errno) + goto fail; + } + + grub_memcpy (data->inode, &fdiro->inode, sizeof (*data->inode)); + grub_free (fdiro); + + inode =3D &(data->inode->i); + file->size =3D grub_f2fs_file_size (inode); + file->data =3D data; + file->offset =3D 0; + + if (inode->i_inline & F2FS_INLINE_DATA && file->size > MAX_INLINE_DATA= ) + grub_error (GRUB_ERR_BAD_FS, "corrupted inline_data: need fsck"); + return 0; + +fail: + if (fdiro !=3D &data->diropen) + grub_free (fdiro); + grub_free (data); + + grub_dl_unref (my_mod); + + return grub_errno; +} + +static grub_ssize_t +grub_f2fs_read (grub_file_t file, char *buf, grub_size_t len) +{ + struct grub_f2fs_data *data =3D (struct grub_f2fs_data *) file->data; + + return grub_f2fs_read_file (&data->diropen, + file->read_hook, file->read_hook_data, + file->offset, len, buf); +} + +static grub_err_t +grub_f2fs_close (grub_file_t file) +{ + struct grub_f2fs_data *data =3D (struct grub_f2fs_data *) file->data; + + grub_free (data); + + grub_dl_unref (my_mod); + + return GRUB_ERR_NONE; +} + +static grub_uint8_t * +grub_f2fs_utf16_to_utf8 (grub_uint16_t *in_buf_le) +{ + grub_uint16_t in_buf[MAX_VOLUME_NAME]; + grub_uint8_t *out_buf; + int len =3D 0; + + out_buf =3D grub_malloc (MAX_VOLUME_NAME * GRUB_MAX_UTF8_PER_UTF16 + 1= ); + if (!out_buf) + return NULL; + + while (*in_buf_le !=3D 0 && len < MAX_VOLUME_NAME) { + in_buf[len] =3D grub_le_to_cpu16 (in_buf_le[len]); + len++; + } + + *grub_utf16_to_utf8 (out_buf, in_buf, len) =3D '\0'; + return out_buf; +} + +static grub_err_t +grub_f2fs_label (grub_device_t device, char **label) +{ + struct grub_f2fs_data *data; + grub_disk_t disk =3D device->disk; + + grub_dl_ref (my_mod); + + data =3D grub_f2fs_mount (disk); + if (data) + *label =3D (char *) grub_f2fs_utf16_to_utf8 (data->sblock.volume_nam= e); + else + *label =3D NULL; + + grub_free (data); + grub_dl_unref (my_mod); + return grub_errno; +} + +static grub_err_t +grub_f2fs_uuid (grub_device_t device, char **uuid) +{ + struct grub_f2fs_data *data; + grub_disk_t disk =3D device->disk; + + grub_dl_ref (my_mod); + + data =3D grub_f2fs_mount (disk); + if (data) + { + *uuid =3D + grub_xasprintf + ("%02x%02x%02x%02x-%02x%02x-%02x%02x-%02x%02x-%02x%02x%02x%02x%02x%02x"= , + data->sblock.uuid[0], data->sblock.uuid[1], + data->sblock.uuid[2], data->sblock.uuid[3], + data->sblock.uuid[4], data->sblock.uuid[5], + data->sblock.uuid[6], data->sblock.uuid[7], + data->sblock.uuid[8], data->sblock.uuid[9], + data->sblock.uuid[10], data->sblock.uuid[11], + data->sblock.uuid[12], data->sblock.uuid[13], + data->sblock.uuid[14], data->sblock.uuid[15]); + } + else + *uuid =3D NULL; + + grub_free (data); + grub_dl_unref (my_mod); + return grub_errno; +} + +static struct grub_fs grub_f2fs_fs =3D { + .name =3D "f2fs", + .dir =3D grub_f2fs_dir, + .open =3D grub_f2fs_open, + .read =3D grub_f2fs_read, + .close =3D grub_f2fs_close, + .label =3D grub_f2fs_label, + .uuid =3D grub_f2fs_uuid, +#ifdef GRUB_UTIL + .reserved_first_sector =3D 1, + .blocklist_install =3D 0, +#endif + .next =3D 0 +}; + +GRUB_MOD_INIT (f2fs) +{ + grub_fs_register (&grub_f2fs_fs); + my_mod =3D mod; +} + +GRUB_MOD_FINI (f2fs) +{ + grub_fs_unregister (&grub_f2fs_fs); +} diff --git a/po/exclude.pot b/po/exclude.pot index 0a9b215..816089c 100644 --- a/po/exclude.pot +++ b/po/exclude.pot @@ -1214,6 +1214,7 @@ msgstr "" =20 #: grub-core/commands/xnu_uuid.c:75 grub-core/fs/jfs.c:924 #: grub-core/fs/nilfs2.c:1135 +#: grub-core/fs/f2fs.c:1259 #, c-format msgid "%02x%02x%02x%02x-%02x%02x-%02x%02x-%02x%02x-%02x%02x%02x%02x%02x%= 02x" msgstr "" diff --git a/tests/f2fs_test.in b/tests/f2fs_test.in new file mode 100644 index 0000000..1ea77c8 --- /dev/null +++ b/tests/f2fs_test.in @@ -0,0 +1,19 @@ +#!/bin/sh + +set -e + +if [ "x$EUID" =3D "x" ] ; then + EUID=3D`id -u` +fi + +if [ "$EUID" !=3D 0 ] ; then + exit 77 +fi + +if ! which mkfs.f2fs >/dev/null 2>&1; then + echo "mkfs.f2fs not installed; cannot test f2fs." + exit 77 +fi + + +"@builddir@/grub-fs-tester" f2fs diff --git a/tests/util/grub-fs-tester.in b/tests/util/grub-fs-tester.in index 424de22..e3e4109 100644 --- a/tests/util/grub-fs-tester.in +++ b/tests/util/grub-fs-tester.in @@ -142,7 +142,7 @@ for ((LOGSECSIZE=3DMINLOGSECSIZE;LOGSECSIZE<=3DMAXLOG= SECSIZE;LOGSECSIZE=3DLOGSECSIZE + xsquash*) MINBLKSIZE=3D4096 MAXBLKSIZE=3D1048576;; - xxfs) + xxfs|xf2fs) MINBLKSIZE=3D$SECSIZE # OS Limitation: GNU/Linux doesn't accept > 4096 MAXBLKSIZE=3D4096;; @@ -265,6 +265,10 @@ for ((LOGSECSIZE=3DMINLOGSECSIZE;LOGSECSIZE<=3DMAXLO= GSECSIZE;LOGSECSIZE=3DLOGSECSIZE + x"btrfs"*) FSLABEL=3D"grub_;/test=C3=A9=F0=AF=A6=9B=F0=AF=A6=9D=F0=9F=98=81=D0= =BA=D0=B8=D1=80=D0=B8=D1=82i urewfceniuewruevrewnuuireurevueurnievrewfner= fcnevirivinrewvnirewnivrewiuvcrewvnuewvrrrewniuerwreiuviurewiuviurewnuvew= nvrenurnunuvrevuurerejiremvreijnvcreivire nverivnreivrevnureiorfnfrvoeoir= oireoireoifrefoieroifoireoif";; =20 + # FS LIMITATION: f2fs label is at most 512 UTF-16 chars + x"f2fs") + FSLABEL=3D"grub_;/test=C3=A9=E4=8F=8C=E4=90=93=E4=8F=95=D0=BA=D0=B8= =D1=80=D0=B8=D1=82iurewfceniuewruewnuuireurevueurnievrewfnerfcnevirivinre= wvnirewnivrewiuvcrewvnuewvrrrewniuerwreiuviurewiuviurewnuvewnvrenurnunuvr= evuurerejiremvreijnvvcreivire nverivnreivrevnureiorfnfrvoeoiroireoireoifr= efoieroifoirvcreivire nverivnreivrevnureiorfnfrvoeoiroireoireoifrefoieroi= foircreivire nverivnreivrevnureiorfnfrvoeoiroireoireoifrefoieroifoireoifo= iq";; + # FS LIMITATION: exfat is at most 15 UTF-16 chars x"exfat") FSLABEL=3D"g=C3=A9=D1=82 ;/=F0=AF=A6=9B=F0=AF=A6=9D=F0=9F=98=81=D0= =BA=D0=B8=D1=80";; @@ -474,7 +478,7 @@ for ((LOGSECSIZE=3DMINLOGSECSIZE;LOGSECSIZE<=3DMAXLOG= SECSIZE;LOGSECSIZE=3DLOGSECSIZE + # FIXME: Not sure about BtrFS, NTFS, JFS, AFS, UDF and SFS. Check i= t. # FS LIMITATION: as far as I know those FS don't store their last modif= ication date. x"jfs_caseins" | x"jfs" | x"xfs" | x"xfs_crc" | x"btrfs"* | x"reiserfs= _old" | x"reiserfs" \ - | x"bfs" | x"afs" \ + | x"bfs" | x"afs" | x"f2fs" \ | x"tarfs" | x"cpio_"* | x"minix" | x"minix2" \ | x"minix3" | x"ntfs"* | x"udf" | x"sfs"*) NOFSTIME=3Dy;; @@ -753,6 +757,8 @@ for ((LOGSECSIZE=3DMINLOGSECSIZE;LOGSECSIZE<=3DMAXLOG= SECSIZE;LOGSECSIZE=3DLOGSECSIZE + MOUNTDEVICE=3D"/dev/mapper/grub_test-testvol" MOUNTFS=3Dext2 "mkfs.ext2" -L "$FSLABEL" -q "${MOUNTDEVICE}" ;; + xf2fs) + "mkfs.f2fs" -l "$FSLABEL" -q "${LODEVICES[0]}" ;; xnilfs2) "mkfs.nilfs2" -L "$FSLABEL" -b $BLKSIZE -q "${LODEVICES[0]}" ;; xext2_old) --=20 2.6.3 From mboxrd@z Thu Jan 1 00:00:00 1970 From: Jaegeuk Kim Subject: Re: [PATCH v7] F2FS support Date: Mon, 22 Feb 2016 10:25:25 -0800 Message-ID: <20160222182525.GD10875@jaegeuk.gateway> References: <1427185140-41120-1-git-send-email-jaegeuk@kernel.org> <20150403224908.GB25673@jaegeuk-mac02.mot.com> <20151119212824.GA11666@jaegeuk.local> <566E7DAA.4010202@gmail.com> <20151215003421.GD48918@jaegeuk.local> <20151215181439.GA60773@jaegeuk.local> <20160108194132.GA17464@jaegeuk.aosp> Mime-Version: 1.0 Content-Type: text/plain; charset="utf-8" Content-Transfer-Encoding: base64 Return-path: Received: from sog-mx-2.v43.ch3.sourceforge.com ([172.29.43.192] helo=mx.sourceforge.net) by sfs-ml-2.v29.ch3.sourceforge.com with esmtp (Exim 4.76) (envelope-from ) id 1aXvAr-0003nB-05 for linux-f2fs-devel@lists.sourceforge.net; Mon, 22 Feb 2016 18:25:33 +0000 Received: from mail.kernel.org ([198.145.29.136]) by sog-mx-2.v43.ch3.sourceforge.com with esmtps (TLSv1:AES256-SHA:256) (Exim 4.76) id 1aXvAn-0003GI-Pi for linux-f2fs-devel@lists.sourceforge.net; Mon, 22 Feb 2016 18:25:32 +0000 Content-Disposition: inline In-Reply-To: <20160108194132.GA17464@jaegeuk.aosp> List-Id: List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Errors-To: linux-f2fs-devel-bounces@lists.sourceforge.net To: Andrei Borzenkov Cc: The development of GNU GRUB , linux-f2fs-devel@lists.sourceforge.net Q2hhbmcgbG9nIGZyb20gdjY6CiBvIHJlbW92ZSByZWR1bmRhbnQgZmlsZXNpemUgY2hlY2sgaW4g LT5yZWFkCiBvIGNoZWNrIGNvbnNpc3RlbmN5IGluIC0+b3BlbiByZWdhcmRpbmcgdG8gaW5saW5l X2RhdGEKCi0tID44IC0tCkZyb20gNTFjMTIwNjEyZmRiYzRiYzMxNWU5YzRjNmU5MWNhODg4YzNm MzU5NiBNb24gU2VwIDE3IDAwOjAwOjAwIDIwMDEKRnJvbTogSmFlZ2V1ayBLaW0gPGphZWdldWtA a2VybmVsLm9yZz4KRGF0ZTogVHVlLCAxNyBOb3YgMjAxNSAxMjo0NToxMyAtMDgwMApTdWJqZWN0 OiBbUEFUQ0hdIEYyRlMgc3VwcG9ydAoKIkYyRlMgKEZsYXNoLUZyaWVuZGx5IEZpbGUgU3lzdGVt KSBpcyBmbGFzaC1mcmllbmRseSBmaWxlIHN5c3RlbSB3aGljaCB3YXMgbWVyZ2VkCmludG8gTGlu dXgga2VybmVsIHYzLjggaW4gMjAxMy4KClRoZSBtb3RpdmUgZm9yIEYyRlMgd2FzIHRvIGJ1aWxk IGEgZmlsZSBzeXN0ZW0gdGhhdCBmcm9tIHRoZSBzdGFydCwgdGFrZXMgaW50bwphY2NvdW50IHRo ZSBjaGFyYWN0ZXJpc3RpY3Mgb2YgTkFORCBmbGFzaCBtZW1vcnktYmFzZWQgc3RvcmFnZSBkZXZp Y2VzIChzdWNoIGFzCnNvbGlkLXN0YXRlIGRpc2tzLCBlTU1DLCBhbmQgU0QgY2FyZHMpLgoKRjJG UyB3YXMgZGVzaWduZWQgb24gYSBiYXNpcyBvZiBhIGxvZy1zdHJ1Y3R1cmVkIGZpbGUgc3lzdGVt IGFwcHJvYWNoLCB3aGljaApyZW1lZGllcyBzb21lIGtub3duIGlzc3VlcyBvZiB0aGUgb2xkZXIg bG9nIHN0cnVjdHVyZWQgZmlsZSBzeXN0ZW1zLCBzdWNoIGFzCnRoZSBzbm93YmFsbCBlZmZlY3Qg b2Ygd2FuZGVyaW5nIHRyZWVzIGFuZCBoaWdoIGNsZWFuaW5nIG92ZXJoZWFkLiBJbiBhZGRpdGlv biwKc2luY2UgYSBOQU5ELWJhc2VkIHN0b3JhZ2UgZGV2aWNlIHNob3dzIGRpZmZlcmVudCBjaGFy YWN0ZXJpc3RpY3MgYWNjb3JkaW5nIHRvCml0cyBpbnRlcm5hbCBnZW9tZXRyeSBvciBmbGFzaCBt ZW1vcnkgbWFuYWdlbWVudCBzY2hlbWUgKHN1Y2ggYXMgdGhlIEZsYXNoClRyYW5zbGF0aW9uIExh eWVyIG9yIEZUTCksIGl0IHN1cHBvcnRzIHZhcmlvdXMgcGFyYW1ldGVycyBub3Qgb25seSBmb3IK Y29uZmlndXJpbmcgb24tZGlzayBsYXlvdXQsIGJ1dCBhbHNvIGZvciBzZWxlY3RpbmcgYWxsb2Nh dGlvbiBhbmQgY2xlYW5pbmcKYWxnb3JpdGhtLiIsIHF1b3RlIGJ5IGh0dHBzOi8vZW4ud2lraXBl ZGlhLm9yZy93aWtpL0YyRlMuCgpUaGUgc291cmNlIGNvZGVzIGZvciBGMkZTIGFyZSBhdmFpbGFi bGUgZnJvbToKCmh0dHA6Ly9naXQua2VybmVsLm9yZy9jZ2l0L2xpbnV4L2tlcm5lbC9naXQvamFl Z2V1ay9mMmZzLmdpdApodHRwOi8vZ2l0Lmtlcm5lbC5vcmcvY2dpdC9saW51eC9rZXJuZWwvZ2l0 L2phZWdldWsvZjJmcy10b29scy5naXQKClNpZ25lZC1vZmYtYnk6IEphZWdldWsgS2ltIDxqYWVn ZXVrQGtlcm5lbC5vcmc+Ci0tLQogTWFrZWZpbGUudXRpbC5kZWYgICAgICAgICAgICB8ICAgIDcg KwogZG9jcy9ncnViLnRleGkgICAgICAgICAgICAgICB8ICAgIDUgKy0KIGdydWItY29yZS9NYWtl ZmlsZS5jb3JlLmRlZiAgfCAgICA1ICsKIGdydWItY29yZS9mcy9mMmZzLmMgICAgICAgICAgfCAx Mjg5ICsrKysrKysrKysrKysrKysrKysrKysrKysrKysrKysrKysrKysrKysrKwogcG8vZXhjbHVk ZS5wb3QgICAgICAgICAgICAgICB8ICAgIDEgKwogdGVzdHMvZjJmc190ZXN0LmluICAgICAgICAg ICB8ICAgMTkgKwogdGVzdHMvdXRpbC9ncnViLWZzLXRlc3Rlci5pbiB8ICAgMTAgKy0KIDcgZmls ZXMgY2hhbmdlZCwgMTMzMiBpbnNlcnRpb25zKCspLCA0IGRlbGV0aW9ucygtKQogY3JlYXRlIG1v ZGUgMTAwNjQ0IGdydWItY29yZS9mcy9mMmZzLmMKIGNyZWF0ZSBtb2RlIDEwMDY0NCB0ZXN0cy9m MmZzX3Rlc3QuaW4KCmRpZmYgLS1naXQgYS9NYWtlZmlsZS51dGlsLmRlZiBiL01ha2VmaWxlLnV0 aWwuZGVmCmluZGV4IGRiN2U4ZWMuLjg0NjI3YmIgMTAwNjQ0Ci0tLSBhL01ha2VmaWxlLnV0aWwu ZGVmCisrKyBiL01ha2VmaWxlLnV0aWwuZGVmCkBAIC05OSw2ICs5OSw3IEBAIGxpYnJhcnkgPSB7 CiAgIGNvbW1vbiA9IGdydWItY29yZS9mcy9leHQyLmM7CiAgIGNvbW1vbiA9IGdydWItY29yZS9m cy9mYXQuYzsKICAgY29tbW9uID0gZ3J1Yi1jb3JlL2ZzL2V4ZmF0LmM7CisgIGNvbW1vbiA9IGdy dWItY29yZS9mcy9mMmZzLmM7CiAgIGNvbW1vbiA9IGdydWItY29yZS9mcy9mc2hlbHAuYzsKICAg Y29tbW9uID0gZ3J1Yi1jb3JlL2ZzL2hmcy5jOwogICBjb21tb24gPSBncnViLWNvcmUvZnMvaGZz cGx1cy5jOwpAQCAtNzY2LDYgKzc2NywxMiBAQCBzY3JpcHQgPSB7CiAKIHNjcmlwdCA9IHsKICAg dGVzdGNhc2U7CisgIG5hbWUgPSBmMmZzX3Rlc3Q7CisgIGNvbW1vbiA9IHRlc3RzL2YyZnNfdGVz dC5pbjsKK307CisKK3NjcmlwdCA9IHsKKyAgdGVzdGNhc2U7CiAgIG5hbWUgPSBuaWxmczJfdGVz dDsKICAgY29tbW9uID0gdGVzdHMvbmlsZnMyX3Rlc3QuaW47CiB9OwpkaWZmIC0tZ2l0IGEvZG9j cy9ncnViLnRleGkgYi9kb2NzL2dydWIudGV4aQppbmRleCAxZGYzZGIyLi5lNWE4MGYzIDEwMDY0 NAotLS0gYS9kb2NzL2dydWIudGV4aQorKysgYi9kb2NzL2dydWIudGV4aQpAQCAtMzYwLDcgKzM2 MCw4IEBAIGJsb2NrbGlzdCBub3RhdGlvbi4gVGhlIGN1cnJlbnRseSBzdXBwb3J0ZWQgZmlsZXN5 c3RlbSB0eXBlcyBhcmUgQGRmbntBbWlnYQogRmFzdCBGaWxlU3lzdGVtIChBRkZTKX0sIEBkZm57 QXRoZU9TIGZzfSwgQGRmbntCZUZTfSwKIEBkZm57QnRyRlN9IChpbmNsdWRpbmcgcmFpZDAsIHJh aWQxLCByYWlkMTAsIGd6aXAgYW5kIGx6byksCiBAZGZue2NwaW99IChsaXR0bGUtIGFuZCBiaWct ZW5kaWFuIGJpbiwgb2RjIGFuZCBuZXdjIHZhcmlhbnRzKSwKLUBkZm57TGludXggZXh0Mi9leHQz L2V4dDR9LCBAZGZue0RPUyBGQVQxMi9GQVQxNi9GQVQzMn0sIEBkZm57ZXhGQVR9LCBAZGZue0hG U30sCitAZGZue0xpbnV4IGV4dDIvZXh0My9leHQ0fSwgQGRmbntET1MgRkFUMTIvRkFUMTYvRkFU MzJ9LCBAZGZue2V4RkFUfSwKK0BkZm57ZjJmc30sIEBkZm57SEZTfSwKIEBkZm57SEZTK30sIEBk Zm57SVNPOTY2MH0gKGluY2x1ZGluZyBKb2xpZXQsIFJvY2stcmlkZ2UgYW5kIG11bHRpLWNodW5r IGZpbGVzKSwKIEBkZm57SkZTfSwgQGRmbntNaW5peCBmc30gKHZlcnNpb25zIDEsIDIgYW5kIDMp LCBAZGZue25pbGZzMn0sCiBAZGZue05URlN9IChpbmNsdWRpbmcgY29tcHJlc3Npb24pLCBAZGZu e1JlaXNlckZTfSwgQGRmbntST01GU30sCkBAIC01MzQ3LDcgKzUzNDgsNyBAQCBOVEZTLCBKRlMs IFVERiwgSEZTKywgZXhGQVQsIGxvbmcgZmlsZW5hbWVzIGluIEZBVCwgSm9saWV0IHBhcnQgb2YK IElTTzk2NjAgYXJlIHRyZWF0ZWQgYXMgVVRGLTE2IGFzIHBlciBzcGVjaWZpY2F0aW9uLiBBRlMg YW5kIEJGUyBhcmUgcmVhZAogYXMgVVRGLTgsIGFnYWluIGFjY29yZGluZyB0byBzcGVjaWZpY2F0 aW9uLiBCdHJGUywgY3BpbywgdGFyLCBzcXVhc2g0LCBtaW5peCwKIG1pbml4MiwgbWluaXgzLCBS T01GUywgUmVpc2VyRlMsIFhGUywgZXh0MiwgZXh0MywgZXh0NCwgRkFUIChzaG9ydCBuYW1lcyks Ci1Sb2NrUmlkZ2UgcGFydCBvZiBJU085NjYwLCBuaWxmczIsIFVGUzEsIFVGUzIgYW5kIFpGUyBh cmUgYXNzdW1lZAorZjJmcywgUm9ja1JpZGdlIHBhcnQgb2YgSVNPOTY2MCwgbmlsZnMyLCBVRlMx LCBVRlMyIGFuZCBaRlMgYXJlIGFzc3VtZWQKIHRvIGJlIFVURi04LiBUaGlzIG1pZ2h0IGJlIGZh bHNlIG9uIHN5c3RlbXMgY29uZmlndXJlZCB3aXRoIGxlZ2FjeSBjaGFyc2V0CiBidXQgYXMgbG9u ZyBhcyB0aGUgY2hhcnNldCB1c2VkIGlzIHN1cGVyc2V0IG9mIEFTQ0lJIHlvdSBzaG91bGQgYmUg YWJsZSB0bwogYWNjZXNzIEFTQ0lJLW5hbWVkIGZpbGVzLiBBbmQgaXQncyByZWNvbW1lbmRlZCB0 byBjb25maWd1cmUgeW91ciBzeXN0ZW0gdG8gdXNlCmRpZmYgLS1naXQgYS9ncnViLWNvcmUvTWFr ZWZpbGUuY29yZS5kZWYgYi9ncnViLWNvcmUvTWFrZWZpbGUuY29yZS5kZWYKaW5kZXggZDlmYTBl My4uYjU4NWFkZSAxMDA2NDQKLS0tIGEvZ3J1Yi1jb3JlL01ha2VmaWxlLmNvcmUuZGVmCisrKyBi L2dydWItY29yZS9NYWtlZmlsZS5jb3JlLmRlZgpAQCAtMTI3OCw2ICsxMjc4LDExIEBAIG1vZHVs ZSA9IHsKIH07CiAKIG1vZHVsZSA9IHsKKyAgbmFtZSA9IGYyZnM7CisgIGNvbW1vbiA9IGZzL2Yy ZnMuYzsKK307CisKK21vZHVsZSA9IHsKICAgbmFtZSA9IGZzaGVscDsKICAgY29tbW9uID0gZnMv ZnNoZWxwLmM7CiB9OwpkaWZmIC0tZ2l0IGEvZ3J1Yi1jb3JlL2ZzL2YyZnMuYyBiL2dydWItY29y ZS9mcy9mMmZzLmMKbmV3IGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggMDAwMDAwMC4uY2IzMTJiMwot LS0gL2Rldi9udWxsCisrKyBiL2dydWItY29yZS9mcy9mMmZzLmMKQEAgLTAsMCArMSwxMjg5IEBA CisvKgorICogIGYyZnMuYyAtIEZsYXNoLUZyaWVuZGx5IEZpbGUgU3lzdGVtCisgKgorICogIFdy aXR0ZW4gYnkgSmFlZ2V1ayBLaW0gPGphZWdldWtAa2VybmVsLm9yZz4KKyAqCisgKiAgQ29weXJp Z2h0IChDKSAyMDE1ICBGcmVlIFNvZnR3YXJlIEZvdW5kYXRpb24sIEluYy4KKyAqCisgKiAgR1JV QiBpcyBmcmVlIHNvZnR3YXJlOiB5b3UgY2FuIHJlZGlzdHJpYnV0ZSBpdCBhbmQvb3IgbW9kaWZ5 CisgKiAgaXQgdW5kZXIgdGhlIHRlcm1zIG9mIHRoZSBHTlUgR2VuZXJhbCBQdWJsaWMgTGljZW5z ZSBhcyBwdWJsaXNoZWQgYnkKKyAqICB0aGUgRnJlZSBTb2Z0d2FyZSBGb3VuZGF0aW9uLCBlaXRo ZXIgdmVyc2lvbiAzIG9mIHRoZSBMaWNlbnNlLCBvcgorICogIChhdCB5b3VyIG9wdGlvbikgYW55 IGxhdGVyIHZlcnNpb24uCisgKgorICogIEdSVUIgaXMgZGlzdHJpYnV0ZWQgaW4gdGhlIGhvcGUg dGhhdCBpdCB3aWxsIGJlIHVzZWZ1bCwKKyAqICBidXQgV0lUSE9VVCBBTlkgV0FSUkFOVFk7IHdp dGhvdXQgZXZlbiB0aGUgaW1wbGllZCB3YXJyYW50eSBvZgorICogIE1FUkNIQU5UQUJJTElUWSBv ciBGSVRORVNTIEZPUiBBIFBBUlRJQ1VMQVIgUFVSUE9TRS4gIFNlZSB0aGUKKyAqICBHTlUgR2Vu ZXJhbCBQdWJsaWMgTGljZW5zZSBmb3IgbW9yZSBkZXRhaWxzLgorICoKKyAqICBZb3Ugc2hvdWxk IGhhdmUgcmVjZWl2ZWQgYSBjb3B5IG9mIHRoZSBHTlUgR2VuZXJhbCBQdWJsaWMgTGljZW5zZQor ICogIGFsb25nIHdpdGggR1JVQi4gIElmIG5vdCwgc2VlIDxodHRwOi8vd3d3LmdudS5vcmcvbGlj ZW5zZXMvPi4KKyAqLworI2luY2x1ZGUgPGdydWIvZXJyLmg+CisjaW5jbHVkZSA8Z3J1Yi9maWxl Lmg+CisjaW5jbHVkZSA8Z3J1Yi9tbS5oPgorI2luY2x1ZGUgPGdydWIvbWlzYy5oPgorI2luY2x1 ZGUgPGdydWIvZGlzay5oPgorI2luY2x1ZGUgPGdydWIvZGwuaD4KKyNpbmNsdWRlIDxncnViL3R5 cGVzLmg+CisjaW5jbHVkZSA8Z3J1Yi9jaGFyc2V0Lmg+CisjaW5jbHVkZSA8Z3J1Yi9mc2hlbHAu aD4KKworR1JVQl9NT0RfTElDRU5TRSAoIkdQTHYzKyIpOworCisvKiBGMkZTIE1hZ2ljIE51bWJl ciAqLworI2RlZmluZSBGMkZTX1NVUEVSX01BR0lDCTB4RjJGNTIwMTAKKyNkZWZpbmUgQ0hFQ0tT VU1fT0ZGU0VUCQk0MDkyCQkvKiBtdXN0IGJlIGFsaWduZWQgNCBieXRlcyAqLworI2RlZmluZSBV MzJfQ0hFQ0tTVU1fT0ZGU0VUCShDSEVDS1NVTV9PRkZTRVQgPj4gMikKKworLyogYnl0ZS1zaXpl IG9mZnNldCAqLworI2RlZmluZSBGMkZTX1NVUEVSX09GRlNFVAkoKGdydWJfZGlza19hZGRyX3Qp MTAyNCkKKyNkZWZpbmUgRjJGU19TVVBFUl9PRkZTRVQwCShGMkZTX1NVUEVSX09GRlNFVCA+PiBH UlVCX0RJU0tfU0VDVE9SX0JJVFMpCisjZGVmaW5lIEYyRlNfU1VQRVJfT0ZGU0VUMQkoKEYyRlNf U1VQRVJfT0ZGU0VUICsgRjJGU19CTEtTSVpFKSA+PglcCisJCQkJCQlHUlVCX0RJU0tfU0VDVE9S X0JJVFMpCisKKy8qIDkgYml0cyBmb3IgNTEyIGJ5dGVzICovCisjZGVmaW5lIEYyRlNfTUlOX0xP R19TRUNUT1JfU0laRQk5CisKKy8qIHN1cHBvcnQgb25seSA0S0IgYmxvY2sgKi8KKyNkZWZpbmUg RjJGU19CTEtfQklUUwkxMgorI2RlZmluZSBGMkZTX0JMS1NJWkUJKDEgPDwgRjJGU19CTEtfQklU UykKKyNkZWZpbmUgRjJGU19CTEtfU0VDX0JJVFMJKEYyRlNfQkxLX0JJVFMgLSBHUlVCX0RJU0tf U0VDVE9SX0JJVFMpCisKKyNkZWZpbmUgVkVSU0lPTl9MRU4JMjU2CisjZGVmaW5lIEYyRlNfTUFY X0VYVEVOU0lPTgk2NAorCisjZGVmaW5lIENQX0NPTVBBQ1RfU1VNX0ZMQUcJMHgwMDAwMDAwNAor I2RlZmluZSBDUF9VTU9VTlRfRkxBRwkweDAwMDAwMDAxCisKKyNkZWZpbmUgTUFYX0FDVElWRV9M T0dTCTE2CisjZGVmaW5lIE1BWF9BQ1RJVkVfTk9ERV9MT0dTCTgKKyNkZWZpbmUgTUFYX0FDVElW RV9EQVRBX0xPR1MJOAorI2RlZmluZQlOUl9DVVJTRUdfREFUQV9UWVBFCTMKKyNkZWZpbmUgTlJf Q1VSU0VHX05PREVfVFlQRQkzCisjZGVmaW5lIE5SX0NVUlNFR19UWVBFCShOUl9DVVJTRUdfREFU QV9UWVBFICsgTlJfQ1VSU0VHX05PREVfVFlQRSkKKworI2RlZmluZSBFTlRSSUVTX0lOX1NVTQk1 MTIKKyNkZWZpbmUJU1VNTUFSWV9TSVpFCTcKKyNkZWZpbmUJU1VNX0ZPT1RFUl9TSVpFCTUKKyNk ZWZpbmUgSkVOVFJZX1NJWkUJKHNpemVvZihzdHJ1Y3QgZ3J1Yl9mMmZzX25hdF9qZW50KSkKKyNk ZWZpbmUgU1VNX0VOVFJJRVNfU0laRQkoU1VNTUFSWV9TSVpFICogRU5UUklFU19JTl9TVU0pCisj ZGVmaW5lIFNVTV9KT1VSTkFMX1NJWkUJKEYyRlNfQkxLU0laRSAtIFNVTV9GT09URVJfU0laRSAt XAorCQkJCVNVTV9FTlRSSUVTX1NJWkUpCisjZGVmaW5lIE5BVF9KT1VSTkFMX0VOVFJJRVMJKChT VU1fSk9VUk5BTF9TSVpFIC0gMikgLyBKRU5UUllfU0laRSkKKyNkZWZpbmUgTkFUX0pPVVJOQUxf UkVTRVJWRUQJKChTVU1fSk9VUk5BTF9TSVpFIC0gMikgJSBKRU5UUllfU0laRSkKKworI2RlZmlu ZSBOQVRfRU5UUllfU0laRSAoc2l6ZW9mKHN0cnVjdCBncnViX2YyZnNfbmF0X2VudHJ5KSkKKyNk ZWZpbmUgTkFUX0VOVFJZX1BFUl9CTE9DSyAoRjJGU19CTEtTSVpFIC8gTkFUX0VOVFJZX1NJWkUp CisKKyNkZWZpbmUgRjJGU19OQU1FX0xFTgkyNTUKKyNkZWZpbmUgRjJGU19TTE9UX0xFTgk4Cisj ZGVmaW5lIE5SX0RFTlRSWV9JTl9CTE9DSwkyMTQKKyNkZWZpbmUgU0laRV9PRl9ESVJfRU5UUlkJ MTEJLyogYnkgYnl0ZSAqLworI2RlZmluZSBCSVRTX1BFUl9CWVRFCTgKKyNkZWZpbmUgU0laRV9P Rl9ERU5UUllfQklUTUFQCSgoTlJfREVOVFJZX0lOX0JMT0NLICsgQklUU19QRVJfQllURSAtIDEp IC8gXAorCQkJCUJJVFNfUEVSX0JZVEUpCisjZGVmaW5lIFNJWkVfT0ZfUkVTRVJWRUQJKEYyRlNf QkxLU0laRSAtICgoU0laRV9PRl9ESVJfRU5UUlkgKyBcCisJCQkJRjJGU19TTE9UX0xFTikgKiBc CisJCQkJTlJfREVOVFJZX0lOX0JMT0NLICsgU0laRV9PRl9ERU5UUllfQklUTUFQKSkKKworI2Rl ZmluZSBGMkZTX0lOTElORV9YQVRUUl9BRERSUwk1MAkvKiAyMDAgYnl0ZXMgZm9yIGlubGluZSB4 YXR0cnMgKi8KKyNkZWZpbmUgREVGX0FERFJTX1BFUl9JTk9ERQk5MjMJLyogQWRkcmVzcyBQb2lu dGVycyBpbiBhbiBJbm9kZSAqLworCisjZGVmaW5lIEFERFJTX1BFUl9CTE9DSwkxMDE4CS8qIEFk ZHJlc3MgUG9pbnRlcnMgaW4gYSBEaXJlY3QgQmxvY2sgKi8KKyNkZWZpbmUgTklEU19QRVJfQkxP Q0sJMTAxOAkvKiBOb2RlIElEcyBpbiBhbiBJbmRpcmVjdCBCbG9jayAqLworI2RlZmluZQlOT0RF X0RJUjFfQkxPQ0sJKERFRl9BRERSU19QRVJfSU5PREUgKyAxKQorI2RlZmluZQlOT0RFX0RJUjJf QkxPQ0sJKERFRl9BRERSU19QRVJfSU5PREUgKyAyKQorI2RlZmluZQlOT0RFX0lORDFfQkxPQ0sJ KERFRl9BRERSU19QRVJfSU5PREUgKyAzKQorI2RlZmluZQlOT0RFX0lORDJfQkxPQ0sJKERFRl9B RERSU19QRVJfSU5PREUgKyA0KQorI2RlZmluZQlOT0RFX0RJTkRfQkxPQ0sJKERFRl9BRERSU19Q RVJfSU5PREUgKyA1KQorCisjZGVmaW5lIE1BWF9JTkxJTkVfREFUQQkoNCAqIChERUZfQUREUlNf UEVSX0lOT0RFIC0gXAorCQkJRjJGU19JTkxJTkVfWEFUVFJfQUREUlMgLSAxKSkKKyNkZWZpbmUg TlJfSU5MSU5FX0RFTlRSWQkoTUFYX0lOTElORV9EQVRBICogQklUU19QRVJfQllURSAvIFwKKwkJ CSgoU0laRV9PRl9ESVJfRU5UUlkgKyBGMkZTX1NMT1RfTEVOKSAqIFwKKwkJCSBCSVRTX1BFUl9C WVRFICsgMSkpCisjZGVmaW5lIElOTElORV9ERU5UUllfQklUTUFQX1NJWkUJKChOUl9JTkxJTkVf REVOVFJZICsgXAorCQkJQklUU19QRVJfQllURSAtIDEpIC8gQklUU19QRVJfQllURSkKKyNkZWZp bmUgSU5MSU5FX1JFU0VSVkVEX1NJWkUJKE1BWF9JTkxJTkVfREFUQSAtIFwKKwkJCSgoU0laRV9P Rl9ESVJfRU5UUlkgKyBGMkZTX1NMT1RfTEVOKSAqIFwKKwkJCSBOUl9JTkxJTkVfREVOVFJZICsg SU5MSU5FX0RFTlRSWV9CSVRNQVBfU0laRSkpCisjZGVmaW5lIENVUlNFR19IT1RfREFUQQkwCisK KyNkZWZpbmUgQ0tQVF9GTEFHX1NFVChja3B0LCBmKQlcCisJCShja3B0KS0+Y2twdF9mbGFncyAm IGdydWJfY3B1X3RvX2xlMzJfY29tcGlsZV90aW1lIChmKQorCisjZGVmaW5lIEYyRlNfSU5MSU5F X1hBVFRSCTB4MDEJLyogZmlsZSBpbmxpbmUgeGF0dHIgZmxhZyAqLworI2RlZmluZSBGMkZTX0lO TElORV9EQVRBCTB4MDIJLyogZmlsZSBpbmxpbmUgZGF0YSBmbGFnICovCisjZGVmaW5lIEYyRlNf SU5MSU5FX0RFTlRSWQkweDA0CS8qIGZpbGUgaW5saW5lIGRlbnRyeSBmbGFnICovCisjZGVmaW5l IEYyRlNfREFUQV9FWElTVAkJMHgwOAkvKiBmaWxlIGlubGluZSBkYXRhIGV4aXN0IGZsYWcgKi8K KyNkZWZpbmUgRjJGU19JTkxJTkVfRE9UUwkweDEwCS8qIGZpbGUgaGF2aW5nIGltcGxpY2l0IGRv dCBkZW50cmllcyAqLworCitlbnVtIEZJTEVfVFlQRQoreworICBGMkZTX0ZUX1VOS05PV04sCisg IEYyRlNfRlRfUkVHX0ZJTEUgPSAxLAorICBGMkZTX0ZUX0RJUiA9IDIsCisgIEYyRlNfRlRfU1lN TElOSyA9IDcsCit9OworCisjZGVmaW5lIE1BWF9WT0xVTUVfTkFNRQkJNTEyCisKK3N0cnVjdCBn cnViX2YyZnNfc3VwZXJibG9jaworeworICBncnViX3VpbnQzMl90IG1hZ2ljOworICBncnViX3Vp bnQxNl90IGR1bW15MVsyXTsKKyAgZ3J1Yl91aW50MzJfdCBsb2dfc2VjdG9yc2l6ZTsKKyAgZ3J1 Yl91aW50MzJfdCBsb2dfc2VjdG9yc19wZXJfYmxvY2s7CisgIGdydWJfdWludDMyX3QgbG9nX2Js b2Nrc2l6ZTsKKyAgZ3J1Yl91aW50MzJfdCBsb2dfYmxvY2tzX3Blcl9zZWc7CisgIGdydWJfdWlu dDMyX3Qgc2Vnc19wZXJfc2VjOworICBncnViX3VpbnQzMl90IHNlY3NfcGVyX3pvbmU7CisgIGdy dWJfdWludDMyX3QgY2hlY2tzdW1fb2Zmc2V0OworICBncnViX3VpbnQ4X3QgZHVtbXkyWzQwXTsK KyAgZ3J1Yl91aW50MzJfdCBjcF9ibGthZGRyOworICBncnViX3VpbnQzMl90IHNpdF9ibGthZGRy OworICBncnViX3VpbnQzMl90IG5hdF9ibGthZGRyOworICBncnViX3VpbnQzMl90IHNzYV9ibGth ZGRyOworICBncnViX3VpbnQzMl90IG1haW5fYmxrYWRkcjsKKyAgZ3J1Yl91aW50MzJfdCByb290 X2lubzsKKyAgZ3J1Yl91aW50MzJfdCBub2RlX2lubzsKKyAgZ3J1Yl91aW50MzJfdCBtZXRhX2lu bzsKKyAgZ3J1Yl91aW50OF90IHV1aWRbMTZdOworICBncnViX3VpbnQxNl90IHZvbHVtZV9uYW1l W01BWF9WT0xVTUVfTkFNRV07CisgIGdydWJfdWludDMyX3QgZXh0ZW5zaW9uX2NvdW50OworICBn cnViX3VpbnQ4X3QgZXh0ZW5zaW9uX2xpc3RbRjJGU19NQVhfRVhURU5TSU9OXVs4XTsKKyAgZ3J1 Yl91aW50MzJfdCBjcF9wYXlsb2FkOworICBncnViX3VpbnQ4X3QgdmVyc2lvbltWRVJTSU9OX0xF Tl07CisgIGdydWJfdWludDhfdCBpbml0X3ZlcnNpb25bVkVSU0lPTl9MRU5dOworfSBHUlVCX1BB Q0tFRDsKKworc3RydWN0IGdydWJfZjJmc19jaGVja3BvaW50Cit7CisgIGdydWJfdWludDY0X3Qg Y2hlY2twb2ludF92ZXI7CisgIGdydWJfdWludDY0X3QgdXNlcl9ibG9ja19jb3VudDsKKyAgZ3J1 Yl91aW50NjRfdCB2YWxpZF9ibG9ja19jb3VudDsKKyAgZ3J1Yl91aW50MzJfdCByc3ZkX3NlZ21l bnRfY291bnQ7CisgIGdydWJfdWludDMyX3Qgb3ZlcnByb3Zfc2VnbWVudF9jb3VudDsKKyAgZ3J1 Yl91aW50MzJfdCBmcmVlX3NlZ21lbnRfY291bnQ7CisgIGdydWJfdWludDMyX3QgY3VyX25vZGVf c2Vnbm9bTUFYX0FDVElWRV9OT0RFX0xPR1NdOworICBncnViX3VpbnQxNl90IGN1cl9ub2RlX2Js a29mZltNQVhfQUNUSVZFX05PREVfTE9HU107CisgIGdydWJfdWludDMyX3QgY3VyX2RhdGFfc2Vn bm9bTUFYX0FDVElWRV9EQVRBX0xPR1NdOworICBncnViX3VpbnQxNl90IGN1cl9kYXRhX2Jsa29m ZltNQVhfQUNUSVZFX0RBVEFfTE9HU107CisgIGdydWJfdWludDMyX3QgY2twdF9mbGFnczsKKyAg Z3J1Yl91aW50MzJfdCBjcF9wYWNrX3RvdGFsX2Jsb2NrX2NvdW50OworICBncnViX3VpbnQzMl90 IGNwX3BhY2tfc3RhcnRfc3VtOworICBncnViX3VpbnQzMl90IHZhbGlkX25vZGVfY291bnQ7Cisg IGdydWJfdWludDMyX3QgdmFsaWRfaW5vZGVfY291bnQ7CisgIGdydWJfdWludDMyX3QgbmV4dF9m cmVlX25pZDsKKyAgZ3J1Yl91aW50MzJfdCBzaXRfdmVyX2JpdG1hcF9ieXRlc2l6ZTsKKyAgZ3J1 Yl91aW50MzJfdCBuYXRfdmVyX2JpdG1hcF9ieXRlc2l6ZTsKKyAgZ3J1Yl91aW50MzJfdCBjaGVj a3N1bV9vZmZzZXQ7CisgIGdydWJfdWludDY0X3QgZWxhcHNlZF90aW1lOworICBncnViX3VpbnQ4 X3QgYWxsb2NfdHlwZVtNQVhfQUNUSVZFX0xPR1NdOworICBncnViX3VpbnQ4X3Qgc2l0X25hdF92 ZXJzaW9uX2JpdG1hcFszOTAwXTsKKyAgZ3J1Yl91aW50MzJfdCBjaGVja3N1bTsKK30gR1JVQl9Q QUNLRUQ7CisKK3N0cnVjdCBncnViX2YyZnNfbmF0X2VudHJ5IHsKKyAgZ3J1Yl91aW50OF90IHZl cnNpb247CisgIGdydWJfdWludDMyX3QgaW5vOworICBncnViX3VpbnQzMl90IGJsb2NrX2FkZHI7 Cit9IEdSVUJfUEFDS0VEOworCitzdHJ1Y3QgZ3J1Yl9mMmZzX25hdF9qZW50Cit7CisgIGdydWJf dWludDMyX3QgbmlkOworICBzdHJ1Y3QgZ3J1Yl9mMmZzX25hdF9lbnRyeSBuZTsKK30gR1JVQl9Q QUNLRUQ7CisKK3N0cnVjdCBncnViX2YyZnNfbmF0X2pvdXJuYWwgeworICBncnViX3VpbnQxNl90 IG5fbmF0czsKKyAgc3RydWN0IGdydWJfZjJmc19uYXRfamVudCBlbnRyaWVzW05BVF9KT1VSTkFM X0VOVFJJRVNdOworICBncnViX3VpbnQ4X3QgcmVzZXJ2ZWRbTkFUX0pPVVJOQUxfUkVTRVJWRURd OworfSBHUlVCX1BBQ0tFRDsKKworc3RydWN0IGdydWJfZjJmc19uYXRfYmxvY2sgeworICBzdHJ1 Y3QgZ3J1Yl9mMmZzX25hdF9lbnRyeSBuZVtOQVRfRU5UUllfUEVSX0JMT0NLXTsKK30gR1JVQl9Q QUNLRUQ7CisKK3N0cnVjdCBncnViX2YyZnNfZGlyX2VudHJ5Cit7CisgIGdydWJfdWludDMyX3Qg aGFzaF9jb2RlOworICBncnViX3VpbnQzMl90IGlubzsKKyAgZ3J1Yl91aW50MTZfdCBuYW1lX2xl bjsKKyAgZ3J1Yl91aW50OF90IGZpbGVfdHlwZTsKK30gR1JVQl9QQUNLRUQ7CisKK3N0cnVjdCBn cnViX2YyZnNfaW5saW5lX2RlbnRyeQoreworICBncnViX3VpbnQ4X3QgZGVudHJ5X2JpdG1hcFtJ TkxJTkVfREVOVFJZX0JJVE1BUF9TSVpFXTsKKyAgZ3J1Yl91aW50OF90IHJlc2VydmVkW0lOTElO RV9SRVNFUlZFRF9TSVpFXTsKKyAgc3RydWN0IGdydWJfZjJmc19kaXJfZW50cnkgZGVudHJ5W05S X0lOTElORV9ERU5UUlldOworICBncnViX3VpbnQ4X3QgZmlsZW5hbWVbTlJfSU5MSU5FX0RFTlRS WV1bRjJGU19TTE9UX0xFTl07Cit9IEdSVUJfUEFDS0VEOworCitzdHJ1Y3QgZ3J1Yl9mMmZzX2Rl bnRyeV9ibG9jayB7CisgIGdydWJfdWludDhfdCBkZW50cnlfYml0bWFwW1NJWkVfT0ZfREVOVFJZ X0JJVE1BUF07CisgIGdydWJfdWludDhfdCByZXNlcnZlZFtTSVpFX09GX1JFU0VSVkVEXTsKKyAg c3RydWN0IGdydWJfZjJmc19kaXJfZW50cnkgZGVudHJ5W05SX0RFTlRSWV9JTl9CTE9DS107Cisg IGdydWJfdWludDhfdCBmaWxlbmFtZVtOUl9ERU5UUllfSU5fQkxPQ0tdW0YyRlNfU0xPVF9MRU5d OworfSBHUlVCX1BBQ0tFRDsKKworc3RydWN0IGdydWJfZjJmc19pbm9kZQoreworICBncnViX3Vp bnQxNl90IGlfbW9kZTsKKyAgZ3J1Yl91aW50OF90IGlfYWR2aXNlOworICBncnViX3VpbnQ4X3Qg aV9pbmxpbmU7CisgIGdydWJfdWludDMyX3QgaV91aWQ7CisgIGdydWJfdWludDMyX3QgaV9naWQ7 CisgIGdydWJfdWludDMyX3QgaV9saW5rczsKKyAgZ3J1Yl91aW50NjRfdCBpX3NpemU7CisgIGdy dWJfdWludDY0X3QgaV9ibG9ja3M7CisgIGdydWJfdWludDY0X3QgaV9hdGltZTsKKyAgZ3J1Yl91 aW50NjRfdCBpX2N0aW1lOworICBncnViX3VpbnQ2NF90IGlfbXRpbWU7CisgIGdydWJfdWludDMy X3QgaV9hdGltZV9uc2VjOworICBncnViX3VpbnQzMl90IGlfY3RpbWVfbnNlYzsKKyAgZ3J1Yl91 aW50MzJfdCBpX210aW1lX25zZWM7CisgIGdydWJfdWludDMyX3QgaV9nZW5lcmF0aW9uOworICBn cnViX3VpbnQzMl90IGlfY3VycmVudF9kZXB0aDsKKyAgZ3J1Yl91aW50MzJfdCBpX3hhdHRyX25p ZDsKKyAgZ3J1Yl91aW50MzJfdCBpX2ZsYWdzOworICBncnViX3VpbnQzMl90IGlfcGlubzsKKyAg Z3J1Yl91aW50MzJfdCBpX25hbWVsZW47CisgIGdydWJfdWludDhfdCBpX25hbWVbRjJGU19OQU1F X0xFTl07CisgIGdydWJfdWludDhfdCBpX2Rpcl9sZXZlbDsKKyAgZ3J1Yl91aW50OF90IGlfZXh0 WzEyXTsKKyAgZ3J1Yl91aW50MzJfdCBpX2FkZHJbREVGX0FERFJTX1BFUl9JTk9ERV07CisgIGdy dWJfdWludDMyX3QgaV9uaWRbNV07Cit9IEdSVUJfUEFDS0VEOworCitzdHJ1Y3QgZ3J1Yl9kaXJl Y3Rfbm9kZSB7CisgIGdydWJfdWludDMyX3QgYWRkcltBRERSU19QRVJfQkxPQ0tdOworfSBHUlVC X1BBQ0tFRDsKKworc3RydWN0IGdydWJfaW5kaXJlY3Rfbm9kZSB7CisgIGdydWJfdWludDMyX3Qg bmlkW05JRFNfUEVSX0JMT0NLXTsKK30gR1JVQl9QQUNLRUQ7CisKK3N0cnVjdCBncnViX2YyZnNf bm9kZQoreworICB1bmlvbgorICB7CisgICAgc3RydWN0IGdydWJfZjJmc19pbm9kZSBpOworICAg IHN0cnVjdCBncnViX2RpcmVjdF9ub2RlIGRuOworICAgIHN0cnVjdCBncnViX2luZGlyZWN0X25v ZGUgaW47CisgICAgY2hhciBidWZbRjJGU19CTEtTSVpFIC0gNDBdOwkvKiBTaG91bGQgb2NjdXB5 IEYyRlNfQkxLU0laRSB0b3RhbGx5ICovCisgIH07CisgIGdydWJfdWludDhfdCBkdW1teVs0MF07 Cit9IEdSVUJfUEFDS0VEOworCitzdHJ1Y3QgZ3J1Yl9mc2hlbHBfbm9kZQoreworICBzdHJ1Y3Qg Z3J1Yl9mMmZzX2RhdGEgKmRhdGE7CisgIHN0cnVjdCBncnViX2YyZnNfbm9kZSBpbm9kZTsKKyAg Z3J1Yl91aW50MzJfdCBpbm87CisgIGludCBpbm9kZV9yZWFkOworfTsKKworc3RydWN0IGdydWJf ZjJmc19kYXRhCit7CisgIHN0cnVjdCBncnViX2YyZnNfc3VwZXJibG9jayBzYmxvY2s7CisgIHN0 cnVjdCBncnViX2YyZnNfY2hlY2twb2ludCBja3B0OworCisgIGdydWJfdWludDMyX3Qgcm9vdF9p bm87CisgIGdydWJfdWludDMyX3QgYmxvY2tzX3Blcl9zZWc7CisgIGdydWJfdWludDMyX3QgY3Bf YmxrYWRkcjsKKyAgZ3J1Yl91aW50MzJfdCBuYXRfYmxrYWRkcjsKKworICBzdHJ1Y3QgZ3J1Yl9m MmZzX25hdF9qb3VybmFsIG5hdF9qOworICBjaGFyICpuYXRfYml0bWFwOworCisgIGdydWJfZGlz a190IGRpc2s7CisgIHN0cnVjdCBncnViX2YyZnNfbm9kZSAqaW5vZGU7CisgIHN0cnVjdCBncnVi X2ZzaGVscF9ub2RlIGRpcm9wZW47Cit9OworCitzdHJ1Y3QgZ3J1Yl9mMmZzX2Rpcl9pdGVyX2N0 eAoreworICBzdHJ1Y3QgZ3J1Yl9mMmZzX2RhdGEgKmRhdGE7CisgIGdydWJfZnNoZWxwX2l0ZXJh dGVfZGlyX2hvb2tfdCBob29rOworICB2b2lkICpob29rX2RhdGE7CisgIGdydWJfdWludDhfdCAq Yml0bWFwOworICBncnViX3VpbnQ4X3QgKCpmaWxlbmFtZSlbRjJGU19TTE9UX0xFTl07CisgIHN0 cnVjdCBncnViX2YyZnNfZGlyX2VudHJ5ICpkZW50cnk7CisgIGludCBtYXg7Cit9OworCitzdHJ1 Y3QgZ3J1Yl9mMmZzX2Rpcl9jdHgKK3sKKyAgZ3J1Yl9mc19kaXJfaG9va190IGhvb2s7CisgIHZv aWQgKmhvb2tfZGF0YTsKKyAgc3RydWN0IGdydWJfZjJmc19kYXRhICpkYXRhOworfTsKKworc3Rh dGljIGdydWJfZGxfdCBteV9tb2Q7CisKK3N0YXRpYyBpbmxpbmUgaW50CitncnViX2YyZnNfdGVz dF9iaXRfbGUgKGludCBuciwgY29uc3QgZ3J1Yl91aW50OF90ICphZGRyKQoreworICByZXR1cm4g YWRkcltuciA+PiAzXSAmICgxIDw8IChuciAmIDcpKTsKK30KKworc3RhdGljIGlubGluZSBjaGFy ICoKK19faW5saW5lX2FkZHIgKHN0cnVjdCBncnViX2YyZnNfaW5vZGUgKmlub2RlKQoreworICBy ZXR1cm4gKGNoYXIgKikmaW5vZGUtPmlfYWRkclsxXTsKK30KKworc3RhdGljIGlubGluZSBncnVi X3VpbnQ2NF90CitncnViX2YyZnNfZmlsZV9zaXplIChzdHJ1Y3QgZ3J1Yl9mMmZzX2lub2RlICpp bm9kZSkKK3sKKyAgcmV0dXJuIGdydWJfbGVfdG9fY3B1NjQgKGlub2RlLT5pX3NpemUpOworfQor CitzdGF0aWMgaW5saW5lIGdydWJfdWludDMyX3QKK19fc3RhcnRfY3BfYWRkciAoc3RydWN0IGdy dWJfZjJmc19kYXRhICpkYXRhKQoreworICBzdHJ1Y3QgZ3J1Yl9mMmZzX2NoZWNrcG9pbnQgKmNr cHQgPSAmZGF0YS0+Y2twdDsKKyAgZ3J1Yl91aW50MzJfdCBzdGFydF9hZGRyID0gZGF0YS0+Y3Bf YmxrYWRkcjsKKworICBpZiAoIShja3B0LT5jaGVja3BvaW50X3ZlciAmIGdydWJfY3B1X3RvX2xl NjRfY29tcGlsZV90aW1lKDEpKSkKKyAgICByZXR1cm4gc3RhcnRfYWRkciArIGRhdGEtPmJsb2Nr c19wZXJfc2VnOworICByZXR1cm4gc3RhcnRfYWRkcjsKK30KKworc3RhdGljIGlubGluZSBncnVi X3VpbnQzMl90CitfX3N0YXJ0X3N1bV9ibG9jayAoc3RydWN0IGdydWJfZjJmc19kYXRhICpkYXRh KQoreworICBzdHJ1Y3QgZ3J1Yl9mMmZzX2NoZWNrcG9pbnQgKmNrcHQgPSAmZGF0YS0+Y2twdDsK KworICByZXR1cm4gX19zdGFydF9jcF9hZGRyIChkYXRhKSArIGdydWJfbGVfdG9fY3B1MzIgKGNr cHQtPmNwX3BhY2tfc3RhcnRfc3VtKTsKK30KKworc3RhdGljIGlubGluZSBncnViX3VpbnQzMl90 CitfX3N1bV9ibGtfYWRkciAoc3RydWN0IGdydWJfZjJmc19kYXRhICpkYXRhLCBpbnQgYmFzZSwg aW50IHR5cGUpCit7CisgIHN0cnVjdCBncnViX2YyZnNfY2hlY2twb2ludCAqY2twdCA9ICZkYXRh LT5ja3B0OworCisgIHJldHVybiBfX3N0YXJ0X2NwX2FkZHIgKGRhdGEpICsKKwlncnViX2xlX3Rv X2NwdTMyIChja3B0LT5jcF9wYWNrX3RvdGFsX2Jsb2NrX2NvdW50KQorCS0gKGJhc2UgKyAxKSAr IHR5cGU7Cit9CisKK3N0YXRpYyBpbmxpbmUgdm9pZCAqCitfX25hdF9iaXRtYXBfcHRyIChzdHJ1 Y3QgZ3J1Yl9mMmZzX2RhdGEgKmRhdGEpCit7CisgIHN0cnVjdCBncnViX2YyZnNfY2hlY2twb2lu dCAqY2twdCA9ICZkYXRhLT5ja3B0OworICBncnViX3VpbnQzMl90IG9mZnNldDsKKworICBpZiAo Z3J1Yl9sZV90b19jcHUzMiAoZGF0YS0+c2Jsb2NrLmNwX3BheWxvYWQpID4gMCkKKyAgICByZXR1 cm4gY2twdC0+c2l0X25hdF92ZXJzaW9uX2JpdG1hcDsKKworICBvZmZzZXQgPSBncnViX2xlX3Rv X2NwdTMyIChja3B0LT5zaXRfdmVyX2JpdG1hcF9ieXRlc2l6ZSk7CisgIHJldHVybiBja3B0LT5z aXRfbmF0X3ZlcnNpb25fYml0bWFwICsgb2Zmc2V0OworfQorCitzdGF0aWMgaW5saW5lIGdydWJf dWludDMyX3QKK19fZ2V0X25vZGVfaWQgKHN0cnVjdCBncnViX2YyZnNfbm9kZSAqcm4sIGludCBv ZmYsIGludCBpbm9kZV9ibG9jaykKK3sKKyAgaWYgKGlub2RlX2Jsb2NrKQorICAgIHJldHVybiBn cnViX2xlX3RvX2NwdTMyIChybi0+aS5pX25pZFtvZmYgLSBOT0RFX0RJUjFfQkxPQ0tdKTsKKyAg cmV0dXJuIGdydWJfbGVfdG9fY3B1MzIgKHJuLT5pbi5uaWRbb2ZmXSk7Cit9CisKK3N0YXRpYyBp bmxpbmUgZ3J1Yl9lcnJfdAorZ3J1Yl9mMmZzX2Jsb2NrX3JlYWQgKHN0cnVjdCBncnViX2YyZnNf ZGF0YSAqZGF0YSwgZ3J1Yl91aW50MzJfdCBibGthZGRyLCB2b2lkICpidWYpCit7CisgIHJldHVy biBncnViX2Rpc2tfcmVhZCAoZGF0YS0+ZGlzaywKKwkJKChncnViX2Rpc2tfYWRkcl90KWJsa2Fk ZHIpIDw8IEYyRlNfQkxLX1NFQ19CSVRTLAorCQkwLCBGMkZTX0JMS1NJWkUsIGJ1Zik7Cit9CisK Ky8qCisgKiBDUkMzMgorKi8KKyNkZWZpbmUgQ1JDUE9MWV9MRSAweGVkYjg4MzIwCisKK3N0YXRp YyBpbmxpbmUgZ3J1Yl91aW50MzJfdAorZ3J1Yl9mMmZzX2NhbF9jcmMzMiAoY29uc3Qgdm9pZCAq YnVmLCBjb25zdCBncnViX3VpbnQzMl90IGxlbikKK3sKKyAgZ3J1Yl91aW50MzJfdCBjcmMgPSBG MkZTX1NVUEVSX01BR0lDOworICB1bnNpZ25lZCBjaGFyICpwID0gKHVuc2lnbmVkIGNoYXIgKili dWY7CisgIGdydWJfdWludDMyX3QgdG1wID0gbGVuOworICBpbnQgaTsKKworICB3aGlsZSAodG1w LS0pCisgICAgeworICAgICAgY3JjIF49ICpwKys7CisgICAgICBmb3IgKGkgPSAwOyBpIDwgODsg aSsrKQorICAgICAgICBjcmMgPSAoY3JjID4+IDEpIF4gKChjcmMgJiAxKSA/IENSQ1BPTFlfTEUg OiAwKTsKKyAgICB9CisgIHJldHVybiBjcmM7Cit9CisKK3N0YXRpYyBpbmxpbmUgaW50CitncnVi X2YyZnNfY3JjX3ZhbGlkIChncnViX3VpbnQzMl90IGJsa19jcmMsIHZvaWQgKmJ1ZiwgY29uc3Qg Z3J1Yl91aW50MzJfdCBsZW4pCit7CisgIGdydWJfdWludDMyX3QgY2FsX2NyYyA9IDA7CisKKyAg Y2FsX2NyYyA9IGdydWJfZjJmc19jYWxfY3JjMzIgKGJ1ZiwgbGVuKTsKKworICByZXR1cm4gKGNh bF9jcmMgPT0gYmxrX2NyYykgPyAxIDogMDsKK30KKworc3RhdGljIGlubGluZSBpbnQKK2dydWJf ZjJmc190ZXN0X2JpdCAoZ3J1Yl91aW50MzJfdCBuciwgY29uc3QgY2hhciAqcCkKK3sKKyAgaW50 IG1hc2s7CisKKyAgcCArPSAobnIgPj4gMyk7CisgIG1hc2sgPSAxIDw8ICg3IC0gKG5yICYgMHgw NykpOworICByZXR1cm4gbWFzayAmICpwOworfQorCitzdGF0aWMgaW50CitncnViX2YyZnNfc2Fu aXR5X2NoZWNrX3NiIChzdHJ1Y3QgZ3J1Yl9mMmZzX3N1cGVyYmxvY2sgKnNiKQoreworICBncnVi X3VpbnQzMl90IGxvZ19zZWN0b3JzaXplLCBsb2dfc2VjdG9yc19wZXJfYmxvY2s7CisKKyAgaWYg KHNiLT5tYWdpYyAhPSBncnViX2NwdV90b19sZTMyX2NvbXBpbGVfdGltZSAoRjJGU19TVVBFUl9N QUdJQykpCisgICAgcmV0dXJuIC0xOworCisgIGlmIChzYi0+bG9nX2Jsb2Nrc2l6ZSAhPSBncnVi X2NwdV90b19sZTMyX2NvbXBpbGVfdGltZSAoRjJGU19CTEtfQklUUykpCisgICAgcmV0dXJuIC0x OworCisgIGxvZ19zZWN0b3JzaXplID0gZ3J1Yl9sZV90b19jcHUzMiAoc2ItPmxvZ19zZWN0b3Jz aXplKTsKKyAgbG9nX3NlY3RvcnNfcGVyX2Jsb2NrID0gZ3J1Yl9sZV90b19jcHUzMiAoc2ItPmxv Z19zZWN0b3JzX3Blcl9ibG9jayk7CisKKyAgaWYgKGxvZ19zZWN0b3JzaXplID4gRjJGU19CTEtf QklUUykKKyAgICByZXR1cm4gLTE7CisKKyAgaWYgKGxvZ19zZWN0b3JzaXplIDwgRjJGU19NSU5f TE9HX1NFQ1RPUl9TSVpFKQorICAgIHJldHVybiAtMTsKKworICBpZiAobG9nX3NlY3RvcnNfcGVy X2Jsb2NrICsgbG9nX3NlY3RvcnNpemUgIT0gRjJGU19CTEtfQklUUykKKyAgICByZXR1cm4gLTE7 CisKKyAgcmV0dXJuIDA7Cit9CisKK3N0YXRpYyBpbnQKK2dydWJfZjJmc19yZWFkX3NiIChzdHJ1 Y3QgZ3J1Yl9mMmZzX2RhdGEgKmRhdGEsIGdydWJfZGlza19hZGRyX3Qgb2Zmc2V0KQoreworICBn cnViX2Rpc2tfdCBkaXNrID0gZGF0YS0+ZGlzazsKKyAgZ3J1Yl9lcnJfdCBlcnI7CisKKyAgLyog UmVhZCBmaXJzdCBzdXBlciBibG9jay4gKi8KKyAgZXJyID0gZ3J1Yl9kaXNrX3JlYWQgKGRpc2ss IG9mZnNldCwgMCwgc2l6ZW9mIChkYXRhLT5zYmxvY2spLCAmZGF0YS0+c2Jsb2NrKTsKKyAgaWYg KGVycikKKyAgICByZXR1cm4gLTE7CisKKyAgcmV0dXJuIGdydWJfZjJmc19zYW5pdHlfY2hlY2tf c2IgKCZkYXRhLT5zYmxvY2spOworfQorCitzdGF0aWMgdm9pZCAqCit2YWxpZGF0ZV9jaGVja3Bv aW50IChzdHJ1Y3QgZ3J1Yl9mMmZzX2RhdGEgKmRhdGEsIGdydWJfdWludDMyX3QgY3BfYWRkciwK KwlncnViX3VpbnQ2NF90ICp2ZXJzaW9uKQoreworICBncnViX3VpbnQzMl90ICpjcF9wYWdlXzEs ICpjcF9wYWdlXzI7CisgIHN0cnVjdCBncnViX2YyZnNfY2hlY2twb2ludCAqY3BfYmxvY2s7Cisg IGdydWJfdWludDY0X3QgY3VyX3ZlcnNpb24gPSAwLCBwcmVfdmVyc2lvbiA9IDA7CisgIGdydWJf dWludDMyX3QgY3JjID0gMDsKKyAgZ3J1Yl91aW50MzJfdCBjcmNfb2Zmc2V0OworICBncnViX2Vy cl90IGVycjsKKworICAvKiBSZWFkIHRoZSAxc3QgY3AgYmxvY2sgaW4gdGhpcyBDUCBwYWNrICov CisgIGNwX3BhZ2VfMSA9IGdydWJfbWFsbG9jIChGMkZTX0JMS1NJWkUpOworICBpZiAoIWNwX3Bh Z2VfMSkKKyAgICByZXR1cm4gTlVMTDsKKworICBlcnIgPSBncnViX2YyZnNfYmxvY2tfcmVhZCAo ZGF0YSwgY3BfYWRkciwgY3BfcGFnZV8xKTsKKyAgaWYgKGVycikKKyAgICBnb3RvIGludmFsaWRf Y3AxOworCisgIGNwX2Jsb2NrID0gKHN0cnVjdCBncnViX2YyZnNfY2hlY2twb2ludCAqKWNwX3Bh Z2VfMTsKKyAgY3JjX29mZnNldCA9IGdydWJfbGVfdG9fY3B1MzIgKGNwX2Jsb2NrLT5jaGVja3N1 bV9vZmZzZXQpOworICBpZiAoY3JjX29mZnNldCAhPSBDSEVDS1NVTV9PRkZTRVQpCisgICAgZ290 byBpbnZhbGlkX2NwMTsKKworICBjcmMgPSBncnViX2xlX3RvX2NwdTMyICgqKGNwX3BhZ2VfMSAr IFUzMl9DSEVDS1NVTV9PRkZTRVQpKTsKKyAgaWYgKCFncnViX2YyZnNfY3JjX3ZhbGlkIChjcmMs IGNwX2Jsb2NrLCBjcmNfb2Zmc2V0KSkKKyAgICBnb3RvIGludmFsaWRfY3AxOworCisgIHByZV92 ZXJzaW9uID0gZ3J1Yl9sZV90b19jcHU2NCAoY3BfYmxvY2stPmNoZWNrcG9pbnRfdmVyKTsKKwor ICAvKiBSZWFkIHRoZSAybmQgY3AgYmxvY2sgaW4gdGhpcyBDUCBwYWNrICovCisgIGNwX3BhZ2Vf MiA9IGdydWJfbWFsbG9jIChGMkZTX0JMS1NJWkUpOworICBpZiAoIWNwX3BhZ2VfMikKKyAgICBn b3RvIGludmFsaWRfY3AxOworCisgIGNwX2FkZHIgKz0gZ3J1Yl9sZV90b19jcHUzMiAoY3BfYmxv Y2stPmNwX3BhY2tfdG90YWxfYmxvY2tfY291bnQpIC0gMTsKKworICBlcnIgPSBncnViX2YyZnNf YmxvY2tfcmVhZCAoZGF0YSwgY3BfYWRkciwgY3BfcGFnZV8yKTsKKyAgaWYgKGVycikKKyAgICBn b3RvIGludmFsaWRfY3AyOworCisgIGNwX2Jsb2NrID0gKHN0cnVjdCBncnViX2YyZnNfY2hlY2tw b2ludCAqKWNwX3BhZ2VfMjsKKyAgY3JjX29mZnNldCA9IGdydWJfbGVfdG9fY3B1MzIgKGNwX2Js b2NrLT5jaGVja3N1bV9vZmZzZXQpOworICBpZiAoY3JjX29mZnNldCAhPSBDSEVDS1NVTV9PRkZT RVQpCisgICAgZ290byBpbnZhbGlkX2NwMjsKKworICBjcmMgPSBncnViX2xlX3RvX2NwdTMyICgq KGNwX3BhZ2VfMiArIFUzMl9DSEVDS1NVTV9PRkZTRVQpKTsKKyAgaWYgKCFncnViX2YyZnNfY3Jj X3ZhbGlkIChjcmMsIGNwX2Jsb2NrLCBjcmNfb2Zmc2V0KSkKKyAgICBnb3RvIGludmFsaWRfY3Ay OworCisgIGN1cl92ZXJzaW9uID0gZ3J1Yl9sZV90b19jcHU2NCAoY3BfYmxvY2stPmNoZWNrcG9p bnRfdmVyKTsKKyAgaWYgKGN1cl92ZXJzaW9uID09IHByZV92ZXJzaW9uKQorICAgIHsKKyAgICAg ICp2ZXJzaW9uID0gY3VyX3ZlcnNpb247CisgICAgICBncnViX2ZyZWUgKGNwX3BhZ2VfMik7Cisg ICAgICByZXR1cm4gY3BfcGFnZV8xOworICAgIH0KKworaW52YWxpZF9jcDI6CisgIGdydWJfZnJl ZSAoY3BfcGFnZV8yKTsKK2ludmFsaWRfY3AxOgorICBncnViX2ZyZWUgKGNwX3BhZ2VfMSk7Cisg IHJldHVybiBOVUxMOworfQorCitzdGF0aWMgZ3J1Yl9lcnJfdAorZ3J1Yl9mMmZzX3JlYWRfY3Ag KHN0cnVjdCBncnViX2YyZnNfZGF0YSAqZGF0YSkKK3sKKyAgdm9pZCAqY3AxLCAqY3AyLCAqY3Vy X3BhZ2U7CisgIGdydWJfdWludDY0X3QgY3AxX3ZlcnNpb24gPSAwLCBjcDJfdmVyc2lvbiA9IDA7 CisgIGdydWJfdWludDY0X3QgY3Bfc3RhcnRfYmxrX25vOworCisgIC8qCisgICAqIEZpbmRpbmcg b3V0IHZhbGlkIGNwIGJsb2NrIGludm9sdmVzIHJlYWQgYm90aAorICAgKiBzZXRzIChjcCBwYWNr MSBhbmQgY3AgcGFjayAyKQorICAgKi8KKyAgY3Bfc3RhcnRfYmxrX25vID0gZGF0YS0+Y3BfYmxr YWRkcjsKKyAgY3AxID0gdmFsaWRhdGVfY2hlY2twb2ludCAoZGF0YSwgY3Bfc3RhcnRfYmxrX25v LCAmY3AxX3ZlcnNpb24pOworICBpZiAoIWNwMSAmJiBncnViX2Vycm5vKQorICAgIHJldHVybiBn cnViX2Vycm5vOworCisgIC8qIFRoZSBzZWNvbmQgY2hlY2twb2ludCBwYWNrIHNob3VsZCBzdGFy dCBhdCB0aGUgbmV4dCBzZWdtZW50ICovCisgIGNwX3N0YXJ0X2Jsa19ubyArPSBkYXRhLT5ibG9j a3NfcGVyX3NlZzsKKyAgY3AyID0gdmFsaWRhdGVfY2hlY2twb2ludCAoZGF0YSwgY3Bfc3RhcnRf YmxrX25vLCAmY3AyX3ZlcnNpb24pOworICBpZiAoIWNwMiAmJiBncnViX2Vycm5vKQorICAgIHsK KyAgICAgIGdydWJfZnJlZSAoY3AxKTsKKyAgICAgIHJldHVybiBncnViX2Vycm5vOworICAgIH0K KworICBpZiAoY3AxICYmIGNwMikKKyAgICBjdXJfcGFnZSA9IChjcDJfdmVyc2lvbiA+IGNwMV92 ZXJzaW9uKSA/IGNwMiA6IGNwMTsKKyAgZWxzZSBpZiAoY3AxKQorICAgIGN1cl9wYWdlID0gY3Ax OworICBlbHNlIGlmIChjcDIpCisgICAgY3VyX3BhZ2UgPSBjcDI7CisgIGVsc2UKKyAgICByZXR1 cm4gZ3J1Yl9lcnJvciAoR1JVQl9FUlJfQkFEX0ZTLCAibm8gY2hlY2twb2ludHMiKTsKKworICBn cnViX21lbWNweSAoJmRhdGEtPmNrcHQsIGN1cl9wYWdlLCBGMkZTX0JMS1NJWkUpOworCisgIGdy dWJfZnJlZSAoY3AxKTsKKyAgZ3J1Yl9mcmVlIChjcDIpOworICByZXR1cm4gMDsKK30KKworc3Rh dGljIGdydWJfZXJyX3QKK2dldF9uYXRfam91cm5hbCAoc3RydWN0IGdydWJfZjJmc19kYXRhICpk YXRhKQoreworICBncnViX3VpbnQzMl90IGJsb2NrOworICBjaGFyICpidWY7CisgIGdydWJfZXJy X3QgZXJyOworCisgIGJ1ZiA9IGdydWJfbWFsbG9jIChGMkZTX0JMS1NJWkUpOworICBpZiAoIWJ1 ZikKKyAgICByZXR1cm4gZ3J1Yl9lcnJubzsKKworICBpZiAoQ0tQVF9GTEFHX1NFVCgmZGF0YS0+ Y2twdCwgQ1BfQ09NUEFDVF9TVU1fRkxBRykpCisgICAgYmxvY2sgPSBfX3N0YXJ0X3N1bV9ibG9j ayAoZGF0YSk7CisgIGVsc2UgaWYgKENLUFRfRkxBR19TRVQgKCZkYXRhLT5ja3B0LCBDUF9VTU9V TlRfRkxBRykpCisgICAgYmxvY2sgPSBfX3N1bV9ibGtfYWRkciAoZGF0YSwgTlJfQ1VSU0VHX1RZ UEUsIENVUlNFR19IT1RfREFUQSk7CisgIGVsc2UKKyAgICBibG9jayA9IF9fc3VtX2Jsa19hZGRy IChkYXRhLCBOUl9DVVJTRUdfREFUQV9UWVBFLCBDVVJTRUdfSE9UX0RBVEEpOworCisgIGVyciA9 IGdydWJfZjJmc19ibG9ja19yZWFkIChkYXRhLCBibG9jaywgYnVmKTsKKyAgaWYgKGVycikKKyAg ICBnb3RvIGZhaWw7CisKKyAgaWYgKENLUFRfRkxBR19TRVQgKCZkYXRhLT5ja3B0LCBDUF9DT01Q QUNUX1NVTV9GTEFHKSkKKyAgICBncnViX21lbWNweSAoJmRhdGEtPm5hdF9qLCBidWYsIFNVTV9K T1VSTkFMX1NJWkUpOworICBlbHNlCisgICAgZ3J1Yl9tZW1jcHkgKCZkYXRhLT5uYXRfaiwgYnVm ICsgU1VNX0VOVFJJRVNfU0laRSwgU1VNX0pPVVJOQUxfU0laRSk7CisKK2ZhaWw6CisgIGdydWJf ZnJlZSAoYnVmKTsKKyAgcmV0dXJuIGVycjsKK30KKworc3RhdGljIGdydWJfdWludDMyX3QKK2dl dF9ibGthZGRyX2Zyb21fbmF0X2pvdXJuYWwgKHN0cnVjdCBncnViX2YyZnNfZGF0YSAqZGF0YSwg Z3J1Yl91aW50MzJfdCBuaWQpCit7CisgIGdydWJfdWludDE2X3QgbiA9IGdydWJfbGVfdG9fY3B1 MTYgKGRhdGEtPm5hdF9qLm5fbmF0cyk7CisgIGdydWJfdWludDMyX3QgYmxrYWRkciA9IDA7Cisg IGdydWJfdWludDE2X3QgaTsKKworICBmb3IgKGkgPSAwOyBpIDwgbjsgaSsrKQorICAgIHsKKyAg ICAgIGlmIChncnViX2xlX3RvX2NwdTMyIChkYXRhLT5uYXRfai5lbnRyaWVzW2ldLm5pZCkgPT0g bmlkKQorICAgICAgICB7CisgICAgICAgICAgYmxrYWRkciA9IGdydWJfbGVfdG9fY3B1MzIgKGRh dGEtPm5hdF9qLmVudHJpZXNbaV0ubmUuYmxvY2tfYWRkcik7CisgICAgICAgICAgYnJlYWs7Cisg ICAgICAgIH0KKyAgICB9CisgIHJldHVybiBibGthZGRyOworfQorCitzdGF0aWMgZ3J1Yl91aW50 MzJfdAorZ2V0X25vZGVfYmxrYWRkciAoc3RydWN0IGdydWJfZjJmc19kYXRhICpkYXRhLCBncnVi X3VpbnQzMl90IG5pZCkKK3sKKyAgc3RydWN0IGdydWJfZjJmc19uYXRfYmxvY2sgKm5hdF9ibG9j azsKKyAgZ3J1Yl91aW50MzJfdCBzZWdfb2ZmLCBibG9ja19vZmYsIGVudHJ5X29mZiwgYmxvY2tf YWRkcjsKKyAgZ3J1Yl91aW50MzJfdCBibGthZGRyOworICBncnViX2Vycl90IGVycjsKKworICBi bGthZGRyID0gZ2V0X2Jsa2FkZHJfZnJvbV9uYXRfam91cm5hbCAoZGF0YSwgbmlkKTsKKyAgaWYg KGJsa2FkZHIpCisgICAgcmV0dXJuIGJsa2FkZHI7CisKKyAgbmF0X2Jsb2NrID0gZ3J1Yl9tYWxs b2MgKEYyRlNfQkxLU0laRSk7CisgIGlmICghbmF0X2Jsb2NrKQorICAgIHJldHVybiAwOworCisg IGJsb2NrX29mZiA9IG5pZCAvIE5BVF9FTlRSWV9QRVJfQkxPQ0s7CisgIGVudHJ5X29mZiA9IG5p ZCAlIE5BVF9FTlRSWV9QRVJfQkxPQ0s7CisKKyAgc2VnX29mZiA9IGJsb2NrX29mZiAvIGRhdGEt PmJsb2Nrc19wZXJfc2VnOworICBibG9ja19hZGRyID0gZGF0YS0+bmF0X2Jsa2FkZHIgKworCSgo c2VnX29mZiAqIGRhdGEtPmJsb2Nrc19wZXJfc2VnKSA8PCAxKSArCisJKGJsb2NrX29mZiAmIChk YXRhLT5ibG9ja3NfcGVyX3NlZyAtIDEpKTsKKworICBpZiAoZ3J1Yl9mMmZzX3Rlc3RfYml0IChi bG9ja19vZmYsIGRhdGEtPm5hdF9iaXRtYXApKQorICAgIGJsb2NrX2FkZHIgKz0gZGF0YS0+Ymxv Y2tzX3Blcl9zZWc7CisKKyAgZXJyID0gZ3J1Yl9mMmZzX2Jsb2NrX3JlYWQgKGRhdGEsIGJsb2Nr X2FkZHIsIG5hdF9ibG9jayk7CisgIGlmIChlcnIpCisgICAgeworICAgICAgZ3J1Yl9mcmVlIChu YXRfYmxvY2spOworICAgICAgcmV0dXJuIDA7CisgICAgfQorCisgIGJsa2FkZHIgPSBncnViX2xl X3RvX2NwdTMyIChuYXRfYmxvY2stPm5lW2VudHJ5X29mZl0uYmxvY2tfYWRkcik7CisKKyAgZ3J1 Yl9mcmVlIChuYXRfYmxvY2spOworCisgIHJldHVybiBibGthZGRyOworfQorCitzdGF0aWMgaW50 CitncnViX2dldF9ub2RlX3BhdGggKHN0cnVjdCBncnViX2YyZnNfaW5vZGUgKmlub2RlLCBncnVi X3VpbnQzMl90IGJsb2NrLAorCWdydWJfdWludDMyX3Qgb2Zmc2V0WzRdLCBncnViX3VpbnQzMl90 IG5vZmZzZXRbNF0pCit7CisgIGdydWJfdWludDMyX3QgZGlyZWN0X2Jsa3MgPSBBRERSU19QRVJf QkxPQ0s7CisgIGdydWJfdWludDMyX3QgZHB0cnNfcGVyX2JsayA9IE5JRFNfUEVSX0JMT0NLOwor ICBncnViX3VpbnQzMl90IGluZGlyZWN0X2Jsa3MgPSBBRERSU19QRVJfQkxPQ0sgKiBOSURTX1BF Ul9CTE9DSzsKKyAgZ3J1Yl91aW50MzJfdCBkaW5kaXJlY3RfYmxrcyA9IGluZGlyZWN0X2Jsa3Mg KiBOSURTX1BFUl9CTE9DSzsKKyAgZ3J1Yl91aW50MzJfdCBkaXJlY3RfaW5kZXggPSBERUZfQURE UlNfUEVSX0lOT0RFOworICBpbnQgbiA9IDA7CisgIGludCBsZXZlbCA9IDA7CisKKyAgaWYgKGlu b2RlLT5pX2lubGluZSAmIEYyRlNfSU5MSU5FX1hBVFRSKQorICAgIGRpcmVjdF9pbmRleCAtPSBG MkZTX0lOTElORV9YQVRUUl9BRERSUzsKKworICBub2Zmc2V0WzBdID0gMDsKKworICBpZiAoYmxv Y2sgPCBkaXJlY3RfaW5kZXgpCisgICAgeworICAgICAgb2Zmc2V0W25dID0gYmxvY2s7CisgICAg ICBnb3RvIGdvdDsKKyAgICB9CisKKyAgYmxvY2sgLT0gZGlyZWN0X2luZGV4OworICBpZiAoYmxv Y2sgPCBkaXJlY3RfYmxrcykKKyAgICB7CisgICAgICBvZmZzZXRbbisrXSA9IE5PREVfRElSMV9C TE9DSzsKKyAgICAgIG5vZmZzZXRbbl0gPSAxOworICAgICAgb2Zmc2V0W25dID0gYmxvY2s7Cisg ICAgICBsZXZlbCA9IDE7CisgICAgICBnb3RvIGdvdDsKKyAgICB9CisKKyAgYmxvY2sgLT0gZGly ZWN0X2Jsa3M7CisgIGlmIChibG9jayA8IGRpcmVjdF9ibGtzKQorICAgIHsKKyAgICAgIG9mZnNl dFtuKytdID0gTk9ERV9ESVIyX0JMT0NLOworICAgICAgbm9mZnNldFtuXSA9IDI7CisgICAgICBv ZmZzZXRbbl0gPSBibG9jazsKKyAgICAgIGxldmVsID0gMTsKKyAgICAgIGdvdG8gZ290OworICAg IH0KKworICBibG9jayAtPSBkaXJlY3RfYmxrczsKKyAgaWYgKGJsb2NrIDwgaW5kaXJlY3RfYmxr cykKKyAgICB7CisgICAgICBvZmZzZXRbbisrXSA9IE5PREVfSU5EMV9CTE9DSzsKKyAgICAgIG5v ZmZzZXRbbl0gPSAzOworICAgICAgb2Zmc2V0W24rK10gPSBibG9jayAvIGRpcmVjdF9ibGtzOwor ICAgICAgbm9mZnNldFtuXSA9IDQgKyBvZmZzZXRbbiAtIDFdOworICAgICAgb2Zmc2V0W25dID0g YmxvY2sgJSBkaXJlY3RfYmxrczsKKyAgICAgIGxldmVsID0gMjsKKyAgICAgIGdvdG8gZ290Owor ICAgIH0KKworICBibG9jayAtPSBpbmRpcmVjdF9ibGtzOworICBpZiAoYmxvY2sgPCBpbmRpcmVj dF9ibGtzKQorICAgIHsKKyAgICAgIG9mZnNldFtuKytdID0gTk9ERV9JTkQyX0JMT0NLOworICAg ICAgbm9mZnNldFtuXSA9IDQgKyBkcHRyc19wZXJfYmxrOworICAgICAgb2Zmc2V0W24rK10gPSBi bG9jayAvIGRpcmVjdF9ibGtzOworICAgICAgbm9mZnNldFtuXSA9IDUgKyBkcHRyc19wZXJfYmxr ICsgb2Zmc2V0W24gLSAxXTsKKyAgICAgIG9mZnNldFtuXSA9IGJsb2NrICUgZGlyZWN0X2Jsa3M7 CisgICAgICBsZXZlbCA9IDI7CisgICAgICBnb3RvIGdvdDsKKyAgICB9CisKKyAgYmxvY2sgLT0g aW5kaXJlY3RfYmxrczsKKyAgaWYgKGJsb2NrIDwgZGluZGlyZWN0X2Jsa3MpCisgICAgeworICAg ICAgb2Zmc2V0W24rK10gPSBOT0RFX0RJTkRfQkxPQ0s7CisgICAgICBub2Zmc2V0W25dID0gNSAr IChkcHRyc19wZXJfYmxrICogMik7CisgICAgICBvZmZzZXRbbisrXSA9IGJsb2NrIC8gaW5kaXJl Y3RfYmxrczsKKyAgICAgIG5vZmZzZXRbbl0gPSA2ICsgKGRwdHJzX3Blcl9ibGsgKiAyKSArCisg ICAgICBvZmZzZXRbbiAtIDFdICogKGRwdHJzX3Blcl9ibGsgKyAxKTsKKyAgICAgIG9mZnNldFtu KytdID0gKGJsb2NrIC8gZGlyZWN0X2Jsa3MpICUgZHB0cnNfcGVyX2JsazsKKyAgICAgIG5vZmZz ZXRbbl0gPSA3ICsgKGRwdHJzX3Blcl9ibGsgKiAyKSArCisJCW9mZnNldFtuIC0gMl0gKiAoZHB0 cnNfcGVyX2JsayArIDEpICsgb2Zmc2V0W24gLSAxXTsKKyAgICAgIG9mZnNldFtuXSA9IGJsb2Nr ICUgZGlyZWN0X2Jsa3M7CisgICAgICBsZXZlbCA9IDM7CisgICAgICBnb3RvIGdvdDsKKyAgICB9 Citnb3Q6CisgIHJldHVybiBsZXZlbDsKK30KKworc3RhdGljIGdydWJfZXJyX3QKK2dydWJfZjJm c19yZWFkX25vZGUgKHN0cnVjdCBncnViX2YyZnNfZGF0YSAqZGF0YSwKKwlncnViX3VpbnQzMl90 IG5pZCwgc3RydWN0IGdydWJfZjJmc19ub2RlICpucCkKK3sKKyAgZ3J1Yl91aW50MzJfdCBibGth ZGRyOworCisgIGJsa2FkZHIgPSBnZXRfbm9kZV9ibGthZGRyIChkYXRhLCBuaWQpOworICBpZiAo IWJsa2FkZHIpCisgICAgcmV0dXJuIGdydWJfZXJybm87CisKKyAgcmV0dXJuIGdydWJfZjJmc19i bG9ja19yZWFkIChkYXRhLCBibGthZGRyLCBucCk7Cit9CisKK3N0YXRpYyBzdHJ1Y3QgZ3J1Yl9m MmZzX2RhdGEgKgorZ3J1Yl9mMmZzX21vdW50IChncnViX2Rpc2tfdCBkaXNrKQoreworICBzdHJ1 Y3QgZ3J1Yl9mMmZzX2RhdGEgKmRhdGE7CisgIGdydWJfZXJyX3QgZXJyOworCisgIGRhdGEgPSBn cnViX21hbGxvYyAoc2l6ZW9mICgqZGF0YSkpOworICBpZiAoIWRhdGEpCisgICAgcmV0dXJuIE5V TEw7CisKKyAgZGF0YS0+ZGlzayA9IGRpc2s7CisKKyAgaWYgKGdydWJfZjJmc19yZWFkX3NiIChk YXRhLCBGMkZTX1NVUEVSX09GRlNFVDApKQorICAgIHsKKyAgICAgIGlmIChncnViX2YyZnNfcmVh ZF9zYiAoZGF0YSwgRjJGU19TVVBFUl9PRkZTRVQxKSkKKyAgICAgICAgeworICAgICAgICAgIGlm IChncnViX2Vycm5vID09IEdSVUJfRVJSX05PTkUpCisgICAgICAgICAgICBncnViX2Vycm9yIChH UlVCX0VSUl9CQURfRlMsCisJCQkibm90IGEgRjJGUyBmaWxlc3lzdGVtIChubyBzdXBlcmJsb2Nr KSIpOworICAgICAgICAgIGdvdG8gZmFpbDsKKyAgICAgICAgfQorICAgIH0KKworICBkYXRhLT5y b290X2lubyA9IGdydWJfbGVfdG9fY3B1MzIgKGRhdGEtPnNibG9jay5yb290X2lubyk7CisgIGRh dGEtPmNwX2Jsa2FkZHIgPSBncnViX2xlX3RvX2NwdTMyIChkYXRhLT5zYmxvY2suY3BfYmxrYWRk cik7CisgIGRhdGEtPm5hdF9ibGthZGRyID0gZ3J1Yl9sZV90b19jcHUzMiAoZGF0YS0+c2Jsb2Nr Lm5hdF9ibGthZGRyKTsKKyAgZGF0YS0+YmxvY2tzX3Blcl9zZWcgPSAxIDw8CisJZ3J1Yl9sZV90 b19jcHUzMiAoZGF0YS0+c2Jsb2NrLmxvZ19ibG9ja3NfcGVyX3NlZyk7CisKKyAgZXJyID0gZ3J1 Yl9mMmZzX3JlYWRfY3AgKGRhdGEpOworICBpZiAoZXJyKQorICAgIGdvdG8gZmFpbDsKKworICBk YXRhLT5uYXRfYml0bWFwID0gX19uYXRfYml0bWFwX3B0ciAoZGF0YSk7CisKKyAgZXJyID0gZ2V0 X25hdF9qb3VybmFsIChkYXRhKTsKKyAgaWYgKGVycikKKyAgICBnb3RvIGZhaWw7CisKKyAgZGF0 YS0+ZGlyb3Blbi5kYXRhID0gZGF0YTsKKyAgZGF0YS0+ZGlyb3Blbi5pbm8gPSBkYXRhLT5yb290 X2lubzsKKyAgZGF0YS0+ZGlyb3Blbi5pbm9kZV9yZWFkID0gMTsKKyAgZGF0YS0+aW5vZGUgPSAm ZGF0YS0+ZGlyb3Blbi5pbm9kZTsKKworICBlcnIgPSBncnViX2YyZnNfcmVhZF9ub2RlIChkYXRh LCBkYXRhLT5yb290X2lubywgZGF0YS0+aW5vZGUpOworICBpZiAoZXJyKQorICAgIGdvdG8gZmFp bDsKKworICByZXR1cm4gZGF0YTsKKworZmFpbDoKKyAgZ3J1Yl9mcmVlIChkYXRhKTsKKyAgcmV0 dXJuIE5VTEw7Cit9CisKKy8qIGd1YXJhbnRlZSBpbmxpbmVfZGF0YSB3YXMgaGFuZGxlZCBieSBj YWxsZXIgKi8KK3N0YXRpYyBncnViX2Rpc2tfYWRkcl90CitncnViX2YyZnNfZ2V0X2Jsb2NrIChn cnViX2ZzaGVscF9ub2RlX3Qgbm9kZSwgZ3J1Yl9kaXNrX2FkZHJfdCBibG9ja19vZnMpCit7Cisg IHN0cnVjdCBncnViX2YyZnNfZGF0YSAqZGF0YSA9IG5vZGUtPmRhdGE7CisgIHN0cnVjdCBncnVi X2YyZnNfaW5vZGUgKmlub2RlID0gJm5vZGUtPmlub2RlLmk7CisgIGdydWJfdWludDMyX3Qgb2Zm c2V0WzRdLCBub2Zmc2V0WzRdLCBuaWRzWzRdOworICBzdHJ1Y3QgZ3J1Yl9mMmZzX25vZGUgKm5v ZGVfYmxvY2s7CisgIGdydWJfdWludDMyX3QgYmxvY2tfYWRkciA9IC0xOworICBpbnQgbGV2ZWws IGk7CisKKyAgbGV2ZWwgPSBncnViX2dldF9ub2RlX3BhdGggKGlub2RlLCBibG9ja19vZnMsIG9m ZnNldCwgbm9mZnNldCk7CisgIGlmIChsZXZlbCA9PSAwKQorICAgIHJldHVybiBncnViX2xlX3Rv X2NwdTMyIChpbm9kZS0+aV9hZGRyW29mZnNldFswXV0pOworCisgIG5vZGVfYmxvY2sgPSBncnVi X21hbGxvYyAoRjJGU19CTEtTSVpFKTsKKyAgaWYgKCFub2RlX2Jsb2NrKQorICAgIHJldHVybiAt MTsKKworICBuaWRzWzFdID0gX19nZXRfbm9kZV9pZCAoJm5vZGUtPmlub2RlLCBvZmZzZXRbMF0s IDEpOworCisgIC8qIGdldCBpbmRpcmVjdCBvciBkaXJlY3Qgbm9kZXMgKi8KKyAgZm9yIChpID0g MTsgaSA8PSBsZXZlbDsgaSsrKQorICAgIHsKKyAgICAgIGdydWJfZjJmc19yZWFkX25vZGUgKGRh dGEsIG5pZHNbaV0sIG5vZGVfYmxvY2spOworICAgICAgaWYgKGdydWJfZXJybm8pCisgICAgICAg IGdvdG8gZmFpbDsKKworICAgICAgaWYgKGkgPCBsZXZlbCkKKyAgICAgICAgbmlkc1tpICsgMV0g PSBfX2dldF9ub2RlX2lkIChub2RlX2Jsb2NrLCBvZmZzZXRbaV0sIDApOworICAgIH0KKworICBi bG9ja19hZGRyID0gZ3J1Yl9sZV90b19jcHUzMiAobm9kZV9ibG9jay0+ZG4uYWRkcltvZmZzZXRb bGV2ZWxdXSk7CitmYWlsOgorICBncnViX2ZyZWUgKG5vZGVfYmxvY2spOworICByZXR1cm4gYmxv Y2tfYWRkcjsKK30KKworc3RhdGljIGdydWJfc3NpemVfdAorZ3J1Yl9mMmZzX3JlYWRfZmlsZSAo Z3J1Yl9mc2hlbHBfbm9kZV90IG5vZGUsCisJCWdydWJfZGlza19yZWFkX2hvb2tfdCByZWFkX2hv b2ssIHZvaWQgKnJlYWRfaG9va19kYXRhLAorCQlncnViX29mZl90IHBvcywgZ3J1Yl9zaXplX3Qg bGVuLCBjaGFyICpidWYpCit7CisgIHN0cnVjdCBncnViX2YyZnNfaW5vZGUgKmlub2RlID0gJm5v ZGUtPmlub2RlLmk7CisgIGdydWJfb2ZmX3QgZmlsZXNpemUgPSBncnViX2YyZnNfZmlsZV9zaXpl IChpbm9kZSk7CisgIGNoYXIgKmlubGluZV9hZGRyID0gX19pbmxpbmVfYWRkciAoaW5vZGUpOwor CisgIGlmIChpbm9kZS0+aV9pbmxpbmUgJiBGMkZTX0lOTElORV9EQVRBKQorICAgIHsKKyAgICAg IGlmIChmaWxlc2l6ZSA+IE1BWF9JTkxJTkVfREFUQSkKKyAgICAgICAgcmV0dXJuIC0xOworICAg ICAgaWYgKGxlbiA+IGZpbGVzaXplIC0gcG9zKQorICAgICAgICBsZW4gPSBmaWxlc2l6ZSAtIHBv czsKKworICAgICAgZ3J1Yl9tZW1jcHkgKGJ1ZiArIHBvcywgaW5saW5lX2FkZHIgKyBwb3MsIGxl bik7CisgICAgICByZXR1cm4gbGVuOworICAgIH0KKworICByZXR1cm4gZ3J1Yl9mc2hlbHBfcmVh ZF9maWxlIChub2RlLT5kYXRhLT5kaXNrLCBub2RlLAorCQkJcmVhZF9ob29rLCByZWFkX2hvb2tf ZGF0YSwKKwkJCXBvcywgbGVuLCBidWYsIGdydWJfZjJmc19nZXRfYmxvY2ssCisJCQlmaWxlc2l6 ZSwKKwkJCUYyRlNfQkxLX1NFQ19CSVRTLCAwKTsKK30KKworc3RhdGljIGNoYXIgKgorZ3J1Yl9m MmZzX3JlYWRfc3ltbGluayAoZ3J1Yl9mc2hlbHBfbm9kZV90IG5vZGUpCit7CisgIGNoYXIgKnN5 bWxpbms7CisgIHN0cnVjdCBncnViX2ZzaGVscF9ub2RlICpkaXJvID0gbm9kZTsKKyAgZ3J1Yl91 aW50NjRfdCBmaWxlc2l6ZTsKKworICBpZiAoIWRpcm8tPmlub2RlX3JlYWQpCisgICAgeworICAg ICAgZ3J1Yl9mMmZzX3JlYWRfbm9kZSAoZGlyby0+ZGF0YSwgZGlyby0+aW5vLCAmZGlyby0+aW5v ZGUpOworICAgICAgaWYgKGdydWJfZXJybm8pCisgICAgICAgIHJldHVybiAwOworICAgIH0KKwor ICBmaWxlc2l6ZSA9IGdydWJfZjJmc19maWxlX3NpemUoJmRpcm8tPmlub2RlLmkpOworCisgIHN5 bWxpbmsgPSBncnViX21hbGxvYyAoZmlsZXNpemUgKyAxKTsKKyAgaWYgKCFzeW1saW5rKQorICAg IHJldHVybiAwOworCisgIGdydWJfZjJmc19yZWFkX2ZpbGUgKGRpcm8sIDAsIDAsIDAsIGZpbGVz aXplLCBzeW1saW5rKTsKKyAgaWYgKGdydWJfZXJybm8pCisgICAgeworICAgICAgZ3J1Yl9mcmVl IChzeW1saW5rKTsKKyAgICAgIHJldHVybiAwOworICAgIH0KKworICBzeW1saW5rW2ZpbGVzaXpl XSA9ICdcMCc7CisgIHJldHVybiBzeW1saW5rOworfQorCitzdGF0aWMgaW50CitncnViX2YyZnNf Y2hlY2tfZGVudHJpZXMgKHN0cnVjdCBncnViX2YyZnNfZGlyX2l0ZXJfY3R4ICpjdHgpCit7Cisg IHN0cnVjdCBncnViX2ZzaGVscF9ub2RlICpmZGlybzsKKyAgaW50IGk7CisKKyAgZm9yIChpID0g MDsgaSA8IGN0eC0+bWF4OykKKyAgICB7CisgICAgICBjaGFyICpmaWxlbmFtZTsKKyAgICAgIGVu dW0gZ3J1Yl9mc2hlbHBfZmlsZXR5cGUgdHlwZSA9IEdSVUJfRlNIRUxQX1VOS05PV047CisgICAg ICBlbnVtIEZJTEVfVFlQRSBmdHlwZTsKKyAgICAgIGludCBuYW1lX2xlbjsKKyAgICAgIGludCBy ZXQ7CisKKyAgICAgIGlmIChncnViX2YyZnNfdGVzdF9iaXRfbGUgKGksIGN0eC0+Yml0bWFwKSA9 PSAwKQorICAgICAgICB7CisgICAgICAgICAgaSsrOworICAgICAgICAgIGNvbnRpbnVlOworICAg ICAgICB9CisKKyAgICAgIGZ0eXBlID0gY3R4LT5kZW50cnlbaV0uZmlsZV90eXBlOworICAgICAg bmFtZV9sZW4gPSBncnViX2xlX3RvX2NwdTE2IChjdHgtPmRlbnRyeVtpXS5uYW1lX2xlbik7Cisg ICAgICBmaWxlbmFtZSA9IGdydWJfbWFsbG9jIChuYW1lX2xlbiArIDEpOworICAgICAgaWYgKCFm aWxlbmFtZSkKKyAgICAgICAgcmV0dXJuIDA7CisKKyAgICAgIGdydWJfbWVtY3B5IChmaWxlbmFt ZSwgY3R4LT5maWxlbmFtZVtpXSwgbmFtZV9sZW4pOworICAgICAgZmlsZW5hbWVbbmFtZV9sZW5d ID0gMDsKKworICAgICAgZmRpcm8gPSBncnViX21hbGxvYyAoc2l6ZW9mIChzdHJ1Y3QgZ3J1Yl9m c2hlbHBfbm9kZSkpOworICAgICAgaWYgKCFmZGlybykKKyAgICAgICAgeworICAgICAgICAgIGdy dWJfZnJlZShmaWxlbmFtZSk7CisgICAgICAgICAgcmV0dXJuIDA7CisgICAgICAgIH0KKworICAg ICAgaWYgKGZ0eXBlID09IEYyRlNfRlRfRElSKQorICAgICAgICB0eXBlID0gR1JVQl9GU0hFTFBf RElSOworICAgICAgZWxzZSBpZiAoZnR5cGUgPT0gRjJGU19GVF9TWU1MSU5LKQorICAgICAgICB0 eXBlID0gR1JVQl9GU0hFTFBfU1lNTElOSzsKKyAgICAgIGVsc2UgaWYgKGZ0eXBlID09IEYyRlNf RlRfUkVHX0ZJTEUpCisgICAgICAgIHR5cGUgPSBHUlVCX0ZTSEVMUF9SRUc7CisKKyAgICAgIGZk aXJvLT5kYXRhID0gY3R4LT5kYXRhOworICAgICAgZmRpcm8tPmlubyA9IGdydWJfbGVfdG9fY3B1 MzIgKGN0eC0+ZGVudHJ5W2ldLmlubyk7CisgICAgICBmZGlyby0+aW5vZGVfcmVhZCA9IDA7CisK KyAgICAgIHJldCA9IGN0eC0+aG9vayAoZmlsZW5hbWUsIHR5cGUsIGZkaXJvLCBjdHgtPmhvb2tf ZGF0YSk7CisgICAgICBncnViX2ZyZWUoZmlsZW5hbWUpOworICAgICAgaWYgKHJldCkKKyAgICAg ICAgcmV0dXJuIDE7CisKKyAgICAgIGkgKz0gKG5hbWVfbGVuICsgRjJGU19TTE9UX0xFTiAtIDEp IC8gRjJGU19TTE9UX0xFTjsKKyAgICB9CisgICAgcmV0dXJuIDA7Cit9CisKK3N0YXRpYyBpbnQK K2dydWJfZjJmc19pdGVyYXRlX2lubGluZV9kaXIgKHN0cnVjdCBncnViX2YyZnNfaW5vZGUgKmRp ciwKKwlzdHJ1Y3QgZ3J1Yl9mMmZzX2Rpcl9pdGVyX2N0eCAqY3R4KQoreworICBzdHJ1Y3QgZ3J1 Yl9mMmZzX2lubGluZV9kZW50cnkgKmRlX2JsazsKKworICBkZV9ibGsgPSAoc3RydWN0IGdydWJf ZjJmc19pbmxpbmVfZGVudHJ5ICopIF9faW5saW5lX2FkZHIgKGRpcik7CisKKyAgY3R4LT5iaXRt YXAgPSBkZV9ibGstPmRlbnRyeV9iaXRtYXA7CisgIGN0eC0+ZGVudHJ5ID0gZGVfYmxrLT5kZW50 cnk7CisgIGN0eC0+ZmlsZW5hbWUgPSBkZV9ibGstPmZpbGVuYW1lOworICBjdHgtPm1heCA9IE5S X0lOTElORV9ERU5UUlk7CisKKyAgcmV0dXJuIGdydWJfZjJmc19jaGVja19kZW50cmllcyAoY3R4 KTsKK30KKworc3RhdGljIGludAorZ3J1Yl9mMmZzX2l0ZXJhdGVfZGlyIChncnViX2ZzaGVscF9u b2RlX3QgZGlyLAorCWdydWJfZnNoZWxwX2l0ZXJhdGVfZGlyX2hvb2tfdCBob29rLCB2b2lkICpo b29rX2RhdGEpCit7CisgIHN0cnVjdCBncnViX2ZzaGVscF9ub2RlICpkaXJvID0gKHN0cnVjdCBn cnViX2ZzaGVscF9ub2RlICopIGRpcjsKKyAgc3RydWN0IGdydWJfZjJmc19pbm9kZSAqaW5vZGU7 CisgIHN0cnVjdCBncnViX2YyZnNfZGlyX2l0ZXJfY3R4IGN0eCA9IHsKKyAgICAuZGF0YSA9IGRp cm8tPmRhdGEsCisgICAgLmhvb2sgPSBob29rLAorICAgIC5ob29rX2RhdGEgPSBob29rX2RhdGEK KyAgfTsKKyAgZ3J1Yl9vZmZfdCBmcG9zID0gMDsKKworICBpZiAoIWRpcm8tPmlub2RlX3JlYWQp CisgICAgeworICAgICAgZ3J1Yl9mMmZzX3JlYWRfbm9kZSAoZGlyby0+ZGF0YSwgZGlyby0+aW5v LCAmZGlyby0+aW5vZGUpOworICAgICAgaWYgKGdydWJfZXJybm8pCisJcmV0dXJuIDA7CisgICAg fQorCisgIGlub2RlID0gJmRpcm8tPmlub2RlLmk7CisKKyAgaWYgKGlub2RlLT5pX2lubGluZSAm IEYyRlNfSU5MSU5FX0RFTlRSWSkKKyAgICByZXR1cm4gZ3J1Yl9mMmZzX2l0ZXJhdGVfaW5saW5l X2RpciAoaW5vZGUsICZjdHgpOworCisgIHdoaWxlIChmcG9zIDwgZ3J1Yl9mMmZzX2ZpbGVfc2l6 ZSAoaW5vZGUpKQorICAgIHsKKyAgICAgIHN0cnVjdCBncnViX2YyZnNfZGVudHJ5X2Jsb2NrICpk ZV9ibGs7CisgICAgICBjaGFyICpidWY7CisgICAgICBpbnQgcmV0OworCisgICAgICBidWYgPSBn cnViX3phbGxvYyAoRjJGU19CTEtTSVpFKTsKKyAgICAgIGlmICghYnVmKQorICAgICAgICByZXR1 cm4gMDsKKworICAgICAgZ3J1Yl9mMmZzX3JlYWRfZmlsZSAoZGlybywgMCwgMCwgZnBvcywgRjJG U19CTEtTSVpFLCBidWYpOworICAgICAgaWYgKGdydWJfZXJybm8pCisgICAgICAgIHsKKyAgICAg ICAgICBncnViX2ZyZWUgKGJ1Zik7CisgICAgICAgICAgcmV0dXJuIDA7CisgICAgICAgIH0KKwor ICAgICAgZGVfYmxrID0gKHN0cnVjdCBncnViX2YyZnNfZGVudHJ5X2Jsb2NrICopIGJ1ZjsKKwor ICAgICAgY3R4LmJpdG1hcCA9IGRlX2Jsay0+ZGVudHJ5X2JpdG1hcDsKKyAgICAgIGN0eC5kZW50 cnkgPSBkZV9ibGstPmRlbnRyeTsKKyAgICAgIGN0eC5maWxlbmFtZSA9IGRlX2Jsay0+ZmlsZW5h bWU7CisgICAgICBjdHgubWF4ID0gTlJfREVOVFJZX0lOX0JMT0NLOworCisgICAgICByZXQgPSBn cnViX2YyZnNfY2hlY2tfZGVudHJpZXMgKCZjdHgpOworICAgICAgZ3J1Yl9mcmVlIChidWYpOwor ICAgICAgaWYgKHJldCkKKyAgICAgICAgcmV0dXJuIDE7CisKKyAgICAgIGZwb3MgKz0gRjJGU19C TEtTSVpFOworICAgIH0KKyAgcmV0dXJuIDA7Cit9CisKK3N0YXRpYyBpbnQKK2dydWJfZjJmc19k aXJfaXRlciAoY29uc3QgY2hhciAqZmlsZW5hbWUsIGVudW0gZ3J1Yl9mc2hlbHBfZmlsZXR5cGUg ZmlsZXR5cGUsCisJICAgICAgZ3J1Yl9mc2hlbHBfbm9kZV90IG5vZGUsIHZvaWQgKmRhdGEpCit7 CisgIHN0cnVjdCBncnViX2YyZnNfZGlyX2N0eCAqY3R4ID0gZGF0YTsKKyAgc3RydWN0IGdydWJf ZGlyaG9va19pbmZvIGluZm87CisKKyAgZ3J1Yl9tZW1zZXQgKCZpbmZvLCAwLCBzaXplb2YgKGlu Zm8pKTsKKyAgaWYgKCFub2RlLT5pbm9kZV9yZWFkKQorICAgIHsKKyAgICAgIGdydWJfZjJmc19y ZWFkX25vZGUgKGN0eC0+ZGF0YSwgbm9kZS0+aW5vLCAmbm9kZS0+aW5vZGUpOworICAgICAgaWYg KCFncnViX2Vycm5vKQorICAgICAgICBub2RlLT5pbm9kZV9yZWFkID0gMTsKKyAgICAgIGdydWJf ZXJybm8gPSBHUlVCX0VSUl9OT05FOworICAgIH0KKyAgaWYgKG5vZGUtPmlub2RlX3JlYWQpCisg ICAgeworICAgICAgaW5mby5tdGltZXNldCA9IDE7CisgICAgICBpbmZvLm10aW1lID0gZ3J1Yl9s ZV90b19jcHU2NCAobm9kZS0+aW5vZGUuaS5pX210aW1lKTsKKyAgICB9CisKKyAgaW5mby5kaXIg PSAoKGZpbGV0eXBlICYgR1JVQl9GU0hFTFBfVFlQRV9NQVNLKSA9PSBHUlVCX0ZTSEVMUF9ESVIp OworICBncnViX2ZyZWUgKG5vZGUpOworICByZXR1cm4gY3R4LT5ob29rIChmaWxlbmFtZSwgJmlu Zm8sIGN0eC0+aG9va19kYXRhKTsKK30KKworc3RhdGljIGdydWJfZXJyX3QKK2dydWJfZjJmc19k aXIgKGdydWJfZGV2aWNlX3QgZGV2aWNlLCBjb25zdCBjaGFyICpwYXRoLAorCWdydWJfZnNfZGly X2hvb2tfdCBob29rLCB2b2lkICpob29rX2RhdGEpCit7CisgIHN0cnVjdCBncnViX2YyZnNfZGly X2N0eCBjdHggPSB7CisgICAgLmhvb2sgPSBob29rLAorICAgIC5ob29rX2RhdGEgPSBob29rX2Rh dGEKKyAgfTsKKyAgc3RydWN0IGdydWJfZnNoZWxwX25vZGUgKmZkaXJvID0gMDsKKworICBncnVi X2RsX3JlZiAobXlfbW9kKTsKKworICBjdHguZGF0YSA9IGdydWJfZjJmc19tb3VudCAoZGV2aWNl LT5kaXNrKTsKKyAgaWYgKCFjdHguZGF0YSkKKyAgICBnb3RvIGZhaWw7CisKKyAgZ3J1Yl9mc2hl bHBfZmluZF9maWxlIChwYXRoLCAmY3R4LmRhdGEtPmRpcm9wZW4sICZmZGlybywKKwkJZ3J1Yl9m MmZzX2l0ZXJhdGVfZGlyLCBncnViX2YyZnNfcmVhZF9zeW1saW5rLAorCQlHUlVCX0ZTSEVMUF9E SVIpOworICBpZiAoZ3J1Yl9lcnJubykKKyAgICBnb3RvIGZhaWw7CisKKyAgZ3J1Yl9mMmZzX2l0 ZXJhdGVfZGlyIChmZGlybywgZ3J1Yl9mMmZzX2Rpcl9pdGVyLCAmY3R4KTsKKworZmFpbDoKKyAg aWYgKGZkaXJvICE9ICZjdHguZGF0YS0+ZGlyb3BlbikKKyAgICBncnViX2ZyZWUgKGZkaXJvKTsK KyBncnViX2ZyZWUgKGN0eC5kYXRhKTsKKyBncnViX2RsX3VucmVmIChteV9tb2QpOworIHJldHVy biBncnViX2Vycm5vOworfQorCisKKy8qIE9wZW4gYSBmaWxlIG5hbWVkIE5BTUUgYW5kIGluaXRp YWxpemUgRklMRS4gICovCitzdGF0aWMgZ3J1Yl9lcnJfdAorZ3J1Yl9mMmZzX29wZW4gKHN0cnVj dCBncnViX2ZpbGUgKmZpbGUsIGNvbnN0IGNoYXIgKm5hbWUpCit7CisgIHN0cnVjdCBncnViX2Yy ZnNfZGF0YSAqZGF0YSA9IE5VTEw7CisgIHN0cnVjdCBncnViX2ZzaGVscF9ub2RlICpmZGlybyA9 IDA7CisgIHN0cnVjdCBncnViX2YyZnNfaW5vZGUgKmlub2RlOworCisgIGdydWJfZGxfcmVmICht eV9tb2QpOworCisgIGRhdGEgPSBncnViX2YyZnNfbW91bnQgKGZpbGUtPmRldmljZS0+ZGlzayk7 CisgIGlmICghZGF0YSkKKyAgICBnb3RvIGZhaWw7CisKKyAgZ3J1Yl9mc2hlbHBfZmluZF9maWxl IChuYW1lLCAmZGF0YS0+ZGlyb3BlbiwgJmZkaXJvLAorCQkJZ3J1Yl9mMmZzX2l0ZXJhdGVfZGly LCBncnViX2YyZnNfcmVhZF9zeW1saW5rLAorCQkJR1JVQl9GU0hFTFBfUkVHKTsKKyAgaWYgKGdy dWJfZXJybm8pCisgICAgZ290byBmYWlsOworCisgIGlmICghZmRpcm8tPmlub2RlX3JlYWQpCisg ICAgeworICAgICAgZ3J1Yl9mMmZzX3JlYWRfbm9kZSAoZGF0YSwgZmRpcm8tPmlubywgJmZkaXJv LT5pbm9kZSk7CisgICAgICBpZiAoZ3J1Yl9lcnJubykKKwlnb3RvIGZhaWw7CisgICAgfQorCisg IGdydWJfbWVtY3B5IChkYXRhLT5pbm9kZSwgJmZkaXJvLT5pbm9kZSwgc2l6ZW9mICgqZGF0YS0+ aW5vZGUpKTsKKyAgZ3J1Yl9mcmVlIChmZGlybyk7CisKKyAgaW5vZGUgPSAmKGRhdGEtPmlub2Rl LT5pKTsKKyAgZmlsZS0+c2l6ZSA9IGdydWJfZjJmc19maWxlX3NpemUgKGlub2RlKTsKKyAgZmls ZS0+ZGF0YSA9IGRhdGE7CisgIGZpbGUtPm9mZnNldCA9IDA7CisKKyAgaWYgKGlub2RlLT5pX2lu bGluZSAmIEYyRlNfSU5MSU5FX0RBVEEgJiYgZmlsZS0+c2l6ZSA+IE1BWF9JTkxJTkVfREFUQSkK KyAgICBncnViX2Vycm9yIChHUlVCX0VSUl9CQURfRlMsICJjb3JydXB0ZWQgaW5saW5lX2RhdGE6 IG5lZWQgZnNjayIpOworICByZXR1cm4gMDsKKworZmFpbDoKKyAgaWYgKGZkaXJvICE9ICZkYXRh LT5kaXJvcGVuKQorICAgIGdydWJfZnJlZSAoZmRpcm8pOworICBncnViX2ZyZWUgKGRhdGEpOwor CisgIGdydWJfZGxfdW5yZWYgKG15X21vZCk7CisKKyAgcmV0dXJuIGdydWJfZXJybm87Cit9CisK K3N0YXRpYyBncnViX3NzaXplX3QKK2dydWJfZjJmc19yZWFkIChncnViX2ZpbGVfdCBmaWxlLCBj aGFyICpidWYsIGdydWJfc2l6ZV90IGxlbikKK3sKKyAgc3RydWN0IGdydWJfZjJmc19kYXRhICpk YXRhID0gKHN0cnVjdCBncnViX2YyZnNfZGF0YSAqKSBmaWxlLT5kYXRhOworCisgIHJldHVybiBn cnViX2YyZnNfcmVhZF9maWxlICgmZGF0YS0+ZGlyb3BlbiwKKwkJZmlsZS0+cmVhZF9ob29rLCBm aWxlLT5yZWFkX2hvb2tfZGF0YSwKKwkJZmlsZS0+b2Zmc2V0LCBsZW4sIGJ1Zik7Cit9CisKK3N0 YXRpYyBncnViX2Vycl90CitncnViX2YyZnNfY2xvc2UgKGdydWJfZmlsZV90IGZpbGUpCit7Cisg IHN0cnVjdCBncnViX2YyZnNfZGF0YSAqZGF0YSA9IChzdHJ1Y3QgZ3J1Yl9mMmZzX2RhdGEgKikg ZmlsZS0+ZGF0YTsKKworICBncnViX2ZyZWUgKGRhdGEpOworCisgIGdydWJfZGxfdW5yZWYgKG15 X21vZCk7CisKKyAgcmV0dXJuIEdSVUJfRVJSX05PTkU7Cit9CisKK3N0YXRpYyBncnViX3VpbnQ4 X3QgKgorZ3J1Yl9mMmZzX3V0ZjE2X3RvX3V0ZjggKGdydWJfdWludDE2X3QgKmluX2J1Zl9sZSkK K3sKKyAgZ3J1Yl91aW50MTZfdCBpbl9idWZbTUFYX1ZPTFVNRV9OQU1FXTsKKyAgZ3J1Yl91aW50 OF90ICpvdXRfYnVmOworICBpbnQgbGVuID0gMDsKKworICBvdXRfYnVmID0gZ3J1Yl9tYWxsb2Mg KE1BWF9WT0xVTUVfTkFNRSAqIEdSVUJfTUFYX1VURjhfUEVSX1VURjE2ICsgMSk7CisgIGlmICgh b3V0X2J1ZikKKyAgICByZXR1cm4gTlVMTDsKKworICB3aGlsZSAoKmluX2J1Zl9sZSAhPSAwICYm IGxlbiA8IE1BWF9WT0xVTUVfTkFNRSkgeworICAgIGluX2J1ZltsZW5dID0gZ3J1Yl9sZV90b19j cHUxNiAoaW5fYnVmX2xlW2xlbl0pOworICAgIGxlbisrOworICB9CisKKyAgKmdydWJfdXRmMTZf dG9fdXRmOCAob3V0X2J1ZiwgaW5fYnVmLCBsZW4pID0gJ1wwJzsKKyAgcmV0dXJuIG91dF9idWY7 Cit9CisKK3N0YXRpYyBncnViX2Vycl90CitncnViX2YyZnNfbGFiZWwgKGdydWJfZGV2aWNlX3Qg ZGV2aWNlLCBjaGFyICoqbGFiZWwpCit7CisgIHN0cnVjdCBncnViX2YyZnNfZGF0YSAqZGF0YTsK KyAgZ3J1Yl9kaXNrX3QgZGlzayA9IGRldmljZS0+ZGlzazsKKworICBncnViX2RsX3JlZiAobXlf bW9kKTsKKworICBkYXRhID0gZ3J1Yl9mMmZzX21vdW50IChkaXNrKTsKKyAgaWYgKGRhdGEpCisg ICAgKmxhYmVsID0gKGNoYXIgKikgZ3J1Yl9mMmZzX3V0ZjE2X3RvX3V0ZjggKGRhdGEtPnNibG9j ay52b2x1bWVfbmFtZSk7CisgIGVsc2UKKyAgICAqbGFiZWwgPSBOVUxMOworCisgIGdydWJfZnJl ZSAoZGF0YSk7CisgIGdydWJfZGxfdW5yZWYgKG15X21vZCk7CisgIHJldHVybiBncnViX2Vycm5v OworfQorCitzdGF0aWMgZ3J1Yl9lcnJfdAorZ3J1Yl9mMmZzX3V1aWQgKGdydWJfZGV2aWNlX3Qg ZGV2aWNlLCBjaGFyICoqdXVpZCkKK3sKKyAgc3RydWN0IGdydWJfZjJmc19kYXRhICpkYXRhOwor ICBncnViX2Rpc2tfdCBkaXNrID0gZGV2aWNlLT5kaXNrOworCisgIGdydWJfZGxfcmVmIChteV9t b2QpOworCisgIGRhdGEgPSBncnViX2YyZnNfbW91bnQgKGRpc2spOworICBpZiAoZGF0YSkKKyAg ICB7CisgICAgICAqdXVpZCA9CisJZ3J1Yl94YXNwcmludGYKKwkoIiUwMnglMDJ4JTAyeCUwMngt JTAyeCUwMngtJTAyeCUwMngtJTAyeCUwMngtJTAyeCUwMnglMDJ4JTAyeCUwMnglMDJ4IiwKKwkJ ZGF0YS0+c2Jsb2NrLnV1aWRbMF0sIGRhdGEtPnNibG9jay51dWlkWzFdLAorCQlkYXRhLT5zYmxv Y2sudXVpZFsyXSwgZGF0YS0+c2Jsb2NrLnV1aWRbM10sCisJCWRhdGEtPnNibG9jay51dWlkWzRd LCBkYXRhLT5zYmxvY2sudXVpZFs1XSwKKwkJZGF0YS0+c2Jsb2NrLnV1aWRbNl0sIGRhdGEtPnNi bG9jay51dWlkWzddLAorCQlkYXRhLT5zYmxvY2sudXVpZFs4XSwgZGF0YS0+c2Jsb2NrLnV1aWRb OV0sCisJCWRhdGEtPnNibG9jay51dWlkWzEwXSwgZGF0YS0+c2Jsb2NrLnV1aWRbMTFdLAorCQlk YXRhLT5zYmxvY2sudXVpZFsxMl0sIGRhdGEtPnNibG9jay51dWlkWzEzXSwKKwkJZGF0YS0+c2Js b2NrLnV1aWRbMTRdLCBkYXRhLT5zYmxvY2sudXVpZFsxNV0pOworICAgIH0KKyAgZWxzZQorICAg ICp1dWlkID0gTlVMTDsKKworICBncnViX2ZyZWUgKGRhdGEpOworICBncnViX2RsX3VucmVmICht eV9tb2QpOworICByZXR1cm4gZ3J1Yl9lcnJubzsKK30KKworc3RhdGljIHN0cnVjdCBncnViX2Zz IGdydWJfZjJmc19mcyA9IHsKKyAgLm5hbWUgPSAiZjJmcyIsCisgIC5kaXIgPSBncnViX2YyZnNf ZGlyLAorICAub3BlbiA9IGdydWJfZjJmc19vcGVuLAorICAucmVhZCA9IGdydWJfZjJmc19yZWFk LAorICAuY2xvc2UgPSBncnViX2YyZnNfY2xvc2UsCisgIC5sYWJlbCA9IGdydWJfZjJmc19sYWJl bCwKKyAgLnV1aWQgPSBncnViX2YyZnNfdXVpZCwKKyNpZmRlZiBHUlVCX1VUSUwKKyAgLnJlc2Vy dmVkX2ZpcnN0X3NlY3RvciA9IDEsCisgIC5ibG9ja2xpc3RfaW5zdGFsbCA9IDAsCisjZW5kaWYK KyAgLm5leHQgPSAwCit9OworCitHUlVCX01PRF9JTklUIChmMmZzKQoreworICBncnViX2ZzX3Jl Z2lzdGVyICgmZ3J1Yl9mMmZzX2ZzKTsKKyAgbXlfbW9kID0gbW9kOworfQorCitHUlVCX01PRF9G SU5JIChmMmZzKQoreworICBncnViX2ZzX3VucmVnaXN0ZXIgKCZncnViX2YyZnNfZnMpOworfQpk aWZmIC0tZ2l0IGEvcG8vZXhjbHVkZS5wb3QgYi9wby9leGNsdWRlLnBvdAppbmRleCAwYTliMjE1 Li44MTYwODljIDEwMDY0NAotLS0gYS9wby9leGNsdWRlLnBvdAorKysgYi9wby9leGNsdWRlLnBv dApAQCAtMTIxNCw2ICsxMjE0LDcgQEAgbXNnc3RyICIiCiAKICM6IGdydWItY29yZS9jb21tYW5k cy94bnVfdXVpZC5jOjc1IGdydWItY29yZS9mcy9qZnMuYzo5MjQKICM6IGdydWItY29yZS9mcy9u aWxmczIuYzoxMTM1CisjOiBncnViLWNvcmUvZnMvZjJmcy5jOjEyNTkKICMsIGMtZm9ybWF0CiBt c2dpZCAiJTAyeCUwMnglMDJ4JTAyeC0lMDJ4JTAyeC0lMDJ4JTAyeC0lMDJ4JTAyeC0lMDJ4JTAy eCUwMnglMDJ4JTAyeCUwMngiCiBtc2dzdHIgIiIKZGlmZiAtLWdpdCBhL3Rlc3RzL2YyZnNfdGVz dC5pbiBiL3Rlc3RzL2YyZnNfdGVzdC5pbgpuZXcgZmlsZSBtb2RlIDEwMDY0NAppbmRleCAwMDAw MDAwLi4xZWE3N2M4Ci0tLSAvZGV2L251bGwKKysrIGIvdGVzdHMvZjJmc190ZXN0LmluCkBAIC0w LDAgKzEsMTkgQEAKKyMhL2Jpbi9zaAorCitzZXQgLWUKKworaWYgWyAieCRFVUlEIiA9ICJ4IiBd IDsgdGhlbgorIEVVSUQ9YGlkIC11YAorZmkKKworaWYgWyAiJEVVSUQiICE9IDAgXSA7IHRoZW4K KyBleGl0IDc3CitmaQorCitpZiAhIHdoaWNoIG1rZnMuZjJmcyA+L2Rldi9udWxsIDI+JjE7IHRo ZW4KKyBlY2hvICJta2ZzLmYyZnMgbm90IGluc3RhbGxlZDsgY2Fubm90IHRlc3QgZjJmcy4iCisg ZXhpdCA3NworZmkKKworCisiQGJ1aWxkZGlyQC9ncnViLWZzLXRlc3RlciIgZjJmcwpkaWZmIC0t Z2l0IGEvdGVzdHMvdXRpbC9ncnViLWZzLXRlc3Rlci5pbiBiL3Rlc3RzL3V0aWwvZ3J1Yi1mcy10 ZXN0ZXIuaW4KaW5kZXggNDI0ZGUyMi4uZTNlNDEwOSAxMDA2NDQKLS0tIGEvdGVzdHMvdXRpbC9n cnViLWZzLXRlc3Rlci5pbgorKysgYi90ZXN0cy91dGlsL2dydWItZnMtdGVzdGVyLmluCkBAIC0x NDIsNyArMTQyLDcgQEAgZm9yICgoTE9HU0VDU0laRT1NSU5MT0dTRUNTSVpFO0xPR1NFQ1NJWkU8 PU1BWExPR1NFQ1NJWkU7TE9HU0VDU0laRT1MT0dTRUNTSVpFICsKIAl4c3F1YXNoKikKIAkgICAg TUlOQkxLU0laRT00MDk2CiAJICAgIE1BWEJMS1NJWkU9MTA0ODU3Njs7Ci0JeHhmcykKKwl4eGZz fHhmMmZzKQogCSAgICBNSU5CTEtTSVpFPSRTRUNTSVpFCiAJCSMgT1MgTGltaXRhdGlvbjogR05V L0xpbnV4IGRvZXNuJ3QgYWNjZXB0ID4gNDA5NgogCSAgICBNQVhCTEtTSVpFPTQwOTY7OwpAQCAt MjY1LDYgKzI2NSwxMCBAQCBmb3IgKChMT0dTRUNTSVpFPU1JTkxPR1NFQ1NJWkU7TE9HU0VDU0la RTw9TUFYTE9HU0VDU0laRTtMT0dTRUNTSVpFPUxPR1NFQ1NJWkUgKwogCQl4ImJ0cmZzIiopCiAJ CSAgICBGU0xBQkVMPSJncnViXzsvdGVzdMOp8K+mm/Cvpp3wn5iB0LrQuNGA0LjRgmkgdXJld2Zj ZW5pdWV3cnVldnJld251dWlyZXVyZXZ1ZXVybmlldnJld2ZuZXJmY25ldmlyaXZpbnJld3ZuaXJl d25pdnJld2l1dmNyZXd2bnVld3ZycnJld25pdWVyd3JlaXV2aXVyZXdpdXZpdXJld251dmV3bnZy ZW51cm51bnV2cmV2dXVyZXJlamlyZW12cmVpam52Y3JlaXZpcmUgbnZlcml2bnJlaXZyZXZudXJl aW9yZm5mcnZvZW9pcm9pcmVvaXJlb2lmcmVmb2llcm9pZm9pcmVvaWYiOzsKIAorCSAgICAjIEZT IExJTUlUQVRJT046IGYyZnMgbGFiZWwgaXMgYXQgbW9zdCA1MTIgVVRGLTE2IGNoYXJzCisJCXgi ZjJmcyIpCisJCSAgICBGU0xBQkVMPSJncnViXzsvdGVzdMOp5I+M5JCT5I+V0LrQuNGA0LjRgml1 cmV3ZmNlbml1ZXdydWV3bnV1aXJldXJldnVldXJuaWV2cmV3Zm5lcmZjbmV2aXJpdmlucmV3dm5p cmV3bml2cmV3aXV2Y3Jld3ZudWV3dnJycmV3bml1ZXJ3cmVpdXZpdXJld2l1dml1cmV3bnV2ZXdu dnJlbnVybnVudXZyZXZ1dXJlcmVqaXJlbXZyZWlqbnZ2Y3JlaXZpcmUgbnZlcml2bnJlaXZyZXZu dXJlaW9yZm5mcnZvZW9pcm9pcmVvaXJlb2lmcmVmb2llcm9pZm9pcnZjcmVpdmlyZSBudmVyaXZu cmVpdnJldm51cmVpb3JmbmZydm9lb2lyb2lyZW9pcmVvaWZyZWZvaWVyb2lmb2lyY3JlaXZpcmUg bnZlcml2bnJlaXZyZXZudXJlaW9yZm5mcnZvZW9pcm9pcmVvaXJlb2lmcmVmb2llcm9pZm9pcmVv aWZvaXEiOzsKKwogCSAgICAjIEZTIExJTUlUQVRJT046IGV4ZmF0IGlzIGF0IG1vc3QgMTUgVVRG LTE2IGNoYXJzCiAJCXgiZXhmYXQiKQogCQkgICAgRlNMQUJFTD0iZ8Op0YIgOy/wr6ab8K+mnfCf mIHQutC40YAiOzsKQEAgLTQ3NCw3ICs0NzgsNyBAQCBmb3IgKChMT0dTRUNTSVpFPU1JTkxPR1NF Q1NJWkU7TE9HU0VDU0laRTw9TUFYTE9HU0VDU0laRTtMT0dTRUNTSVpFPUxPR1NFQ1NJWkUgKwog CSAgICAjIEZJWE1FOiBOb3Qgc3VyZSBhYm91dCBCdHJGUywgTlRGUywgSkZTLCBBRlMsIFVERiBh bmQgU0ZTLiBDaGVjayBpdC4KIAkjIEZTIExJTUlUQVRJT046IGFzIGZhciBhcyBJIGtub3cgdGhv c2UgRlMgZG9uJ3Qgc3RvcmUgdGhlaXIgbGFzdCBtb2RpZmljYXRpb24gZGF0ZS4KIAkJeCJqZnNf Y2FzZWlucyIgfCB4ImpmcyIgfCB4InhmcyIgfCB4Inhmc19jcmMiIHwgeCJidHJmcyIqIHwgeCJy ZWlzZXJmc19vbGQiIHwgeCJyZWlzZXJmcyIgXAotCQkgICAgfCB4ImJmcyIgfCB4ImFmcyIgXAor CQkgICAgfCB4ImJmcyIgfCB4ImFmcyIgfCB4ImYyZnMiIFwKIAkJICAgIHwgeCJ0YXJmcyIgfCB4 ImNwaW9fIiogfCB4Im1pbml4IiB8IHgibWluaXgyIiBcCiAJCSAgICB8IHgibWluaXgzIiB8IHgi bnRmcyIqIHwgeCJ1ZGYiIHwgeCJzZnMiKikKIAkJICAgIE5PRlNUSU1FPXk7OwpAQCAtNzUzLDYg Kzc1Nyw4IEBAIGZvciAoKExPR1NFQ1NJWkU9TUlOTE9HU0VDU0laRTtMT0dTRUNTSVpFPD1NQVhM T0dTRUNTSVpFO0xPR1NFQ1NJWkU9TE9HU0VDU0laRSArCiAJCSAgICBNT1VOVERFVklDRT0iL2Rl di9tYXBwZXIvZ3J1Yl90ZXN0LXRlc3R2b2wiCiAJCSAgICBNT1VOVEZTPWV4dDIKIAkJICAgICJt a2ZzLmV4dDIiIC1MICIkRlNMQUJFTCIgLXEgIiR7TU9VTlRERVZJQ0V9IiAgOzsKKwkJeGYyZnMp CisJCSAgICAibWtmcy5mMmZzIiAtbCAiJEZTTEFCRUwiIC1xICIke0xPREVWSUNFU1swXX0iIDs7 CiAJCXhuaWxmczIpCiAJCSAgICAibWtmcy5uaWxmczIiIC1MICIkRlNMQUJFTCIgLWIgJEJMS1NJ WkUgIC1xICIke0xPREVWSUNFU1swXX0iIDs7CiAJCXhleHQyX29sZCkKLS0gCjIuNi4zCgoKLS0t LS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0t LS0tLS0tLS0tLS0tLS0tLS0tClNpdGUyNHg3IEFQTSBJbnNpZ2h0OiBHZXQgRGVlcCBWaXNpYmls aXR5IGludG8gQXBwbGljYXRpb24gUGVyZm9ybWFuY2UKQVBNICsgTW9iaWxlIEFQTSArIFJVTTog TW9uaXRvciAzIEFwcCBpbnN0YW5jZXMgYXQganVzdCAkMzUvTW9udGgKTW9uaXRvciBlbmQtdG8t ZW5kIHdlYiB0cmFuc2FjdGlvbnMgYW5kIHRha2UgY29ycmVjdGl2ZSBhY3Rpb25zIG5vdwpUcm91 Ymxlc2hvb3QgZmFzdGVyIGFuZCBpbXByb3ZlIGVuZC11c2VyIGV4cGVyaWVuY2UuIFNpZ251cCBO b3chCmh0dHA6Ly9wdWJhZHMuZy5kb3VibGVjbGljay5uZXQvZ2FtcGFkL2Nsaz9pZD0yNzI0ODcx NTEmaXU9LzQxNDAKX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19f X18KTGludXgtZjJmcy1kZXZlbCBtYWlsaW5nIGxpc3QKTGludXgtZjJmcy1kZXZlbEBsaXN0cy5z b3VyY2Vmb3JnZS5uZXQKaHR0cHM6Ly9saXN0cy5zb3VyY2Vmb3JnZS5uZXQvbGlzdHMvbGlzdGlu Zm8vbGludXgtZjJmcy1kZXZlbAo=