external/f2fs-tools/Android.bp

// Copyright 2017 The Android Open Source Project

package {
    default_applicable_licenses: ["external_f2fs-tools_license"],
}

// Added automatically by a large-scale-change that took the approach of
// 'apply every license found to every target'. While this makes sure we respect
// every license restriction, it may not be entirely correct.
//
// e.g. GPL in an MIT project might only apply to the contrib/ directory.
//
// Please consider splitting the single license below into multiple licenses,
// taking care not to lose any license_kind information, and overriding the
// default license using the 'licenses: [...]' property on targets as needed.
//
// For unused files, consider creating a 'fileGroup' with "//visibility:private"
// to attach the license to, and including a comment whether the files may be
// used in the current project.
//
// large-scale-change included anything that looked like it might be a license
// text as a license_text. e.g. LICENSE, NOTICE, COPYING etc.
//
// Please consider removing redundant or irrelevant files from 'license_text:'.
// See: http://go/android-license-faq
license {
    name: "external_f2fs-tools_license",
    visibility: [":__subpackages__"],
    license_kinds: [
        "SPDX-license-identifier-BSD",
        "SPDX-license-identifier-GPL",
        "SPDX-license-identifier-GPL-2.0",
        "SPDX-license-identifier-LGPL",
        "SPDX-license-identifier-LGPL-2.1",
    ],
    license_text: [
        "COPYING",
        "NOTICE",
    ],
}

cc_defaults {
    name: "f2fs-tools-defaults",
    cflags: [
        "-DF2FS_MAJOR_VERSION=1",
        "-DF2FS_MINOR_VERSION=16",
        "-DF2FS_TOOLS_DATE=\"2023-04-11\"",
        "-DF2FS_TOOLS_VERSION=\"1.16.0\"",
        "-DWITH_ANDROID",
        "-D_FILE_OFFSET_BITS=64",
        "-Wall",
        "-Werror",
        "-Wno-macro-redefined",
        "-Wno-missing-field-initializers",
        "-Wno-pointer-arith",
        "-Wno-sign-compare",
    ],
    local_include_dirs: [
        "fsck",
        "include",
        "mkfs",
    ],
    target: {
        windows: {
            enabled: false,
        },
    },
}

cc_defaults {
    name: "libf2fs_src_files",
    cflags: ["-DWITH_BLKDISCARD"],
    srcs: [
        "lib/libf2fs.c",
        "lib/libf2fs_zoned.c",
        "lib/nls_utf8.c",
        "mkfs/f2fs_format.c",
        "mkfs/f2fs_format_utils.c",
    ],
    static_libs: [
        "libext2_uuid",
    ],
}

cc_defaults {
    name: "make_f2fs_src_files",
    srcs: [
        "lib/libf2fs_io.c",
        "mkfs/f2fs_format_main.c",
    ],
}

cc_defaults {
    name: "fsck_main_src_files",
    srcs: [
        "fsck/dict.c",
        "fsck/dir.c",
        "fsck/dump.c",
        "fsck/main.c",
        "fsck/mkquota.c",
        "fsck/mount.c",
        "fsck/node.c",
        "fsck/quotaio.c",
        "fsck/quotaio_tree.c",
        "fsck/quotaio_v2.c",
        "fsck/segment.c",
        "fsck/xattr.c",
        "lib/libf2fs.c",
        "lib/libf2fs_io.c",
        "lib/libf2fs_zoned.c",
        "lib/nls_utf8.c",
    ],
}

cc_library_static {
    name: "libf2fs_fmt",
    recovery_available: true,
    defaults: [
        "f2fs-tools-defaults",
        "libf2fs_src_files",
    ],
}

cc_library_host_static {
    name: "libf2fs_fmt_host",
    defaults: [
        "f2fs-tools-defaults",
        "libf2fs_src_files",
    ],
    target: {
        windows: {
            include_dirs: ["external/e2fsprogs/include/mingw"],
            cflags: [
                "-DANDROID_WINDOWS_HOST",
                "-Wno-typedef-redefinition",
                "-Wno-unused-parameter",
            ],
            enabled: true,
        },
    },
}

cc_defaults {
    name: "make_f2fs_defaults",
    defaults: [
        "f2fs-tools-defaults",
        "make_f2fs_src_files",
    ],
    target: {
        android: {
            static_libs: [
                "libf2fs_fmt",
            ],
            shared_libs: [
                "libbase",
                "libext2_uuid",
                "libsparse",
            ],
        },
    },
}

cc_defaults {
    name: "make_f2fs_host_defaults",
    defaults: [
        "make_f2fs_defaults",
    ],
    host_supported: true,
    target: {
        host: {
            static_libs: [
                "libbase",
                "libext2_uuid",
                "libf2fs_fmt_host",
                "libsparse",
                "libz",
            ],
        },
        windows: {
            include_dirs: ["external/e2fsprogs/include/mingw"],
            cflags: ["-DANDROID_WINDOWS_HOST"],
            ldflags: ["-static"],
            host_ldlibs: ["-lws2_32"],
            enabled: true,
        },
    },
}

cc_binary {
    name: "make_f2fs",
    defaults: [
        "make_f2fs_host_defaults",
    ],
    target: {
        host: {
            dist: {
                targets: [
                    "dist_files",
                    "sdk",
                ],
            },
        },
    },
}

cc_binary {
    name: "make_f2fs.recovery",
    defaults: [
        "make_f2fs_defaults",
    ],
    recovery: true,
    stem: "make_f2fs",
}

cc_binary_host {
    name: "make_f2fs_casefold",
    defaults: [
        "make_f2fs_host_defaults",
    ],
    recovery_available: true,
    target: {
        host: {
            cflags: [
                "-DCONF_CASEFOLD",
                "-DCONF_PROJID",
            ],
            dist: {
                targets: [
                    "dist_files",
                    "sdk",
                ],
            },
        },
        windows: {
            cflags: [
                "-DCONF_CASEFOLD",
                "-DCONF_PROJID",
            ],
        },
    },
}

cc_binary_host {
    name: "make_f2fs.static",
    defaults: [
        "make_f2fs_host_defaults",
    ],
    recovery_available: true,
    static_executable: true,
    stl: "libc++_static",
}

cc_defaults {
    name: "fsck.f2fs_defaults",
    defaults: [
        "f2fs-tools-defaults",
        "fsck_main_src_files",
    ],
    cflags: [
        "-DWITH_DEFRAG",
        "-DWITH_DUMP",
        "-DWITH_RESIZE",
    ],
    srcs: [
        "fsck/defrag.c",
        "fsck/fsck.c",
        "fsck/resize.c",
    ],
}

cc_defaults {
    name: "fsck.f2fs_partition_common_defaults",
    defaults: [
        "f2fs-tools-defaults",
        "fsck.f2fs_defaults",
        "fsck_main_src_files",
    ],
    symlinks: [
        "defrag.f2fs",
        "dump.f2fs",
        "resize.f2fs",
    ],
    shared_libs: [
        "libbase",
        "libext2_uuid",
        "libsparse",
    ],
    bootstrap: true,
}

cc_binary {
    name: "fsck.f2fs",
    defaults: [
        "fsck.f2fs_partition_common_defaults",
    ],
    host_supported: true,
    vendor_available: true,
    vendor_ramdisk_available: true,
    bootstrap: true,
}

cc_binary {
    name: "fsck.f2fs.recovery",
    defaults: [
        "fsck.f2fs_partition_common_defaults",
    ],
    recovery: true,
    bootstrap: true,
    stem: "fsck.f2fs",
}

cc_binary {
    name: "fsck.f2fs_ramdisk",
    stem: "fsck.f2fs",
    defaults: [
        "f2fs-tools-defaults",
        "fsck.f2fs_defaults",
        "fsck_main_src_files",
    ],
    static_executable: true,
    ramdisk: true,
    static_libs: [
        "libbase",
        "libext2_uuid",
        "libsparse",
        "libz",
    ],
}

cc_defaults {
    name: "sload_f2fs_defaults",
    defaults: [
        "f2fs-tools-defaults",
        "fsck_main_src_files",
    ],
    cflags: ["-DWITH_SLOAD"],
    srcs: [
        "fsck/compress.c",
        "fsck/fsck.c",
        "fsck/sload.c",
    ],
    target: {
        android: {
            shared_libs: [
                "libbase",
                "libcrypto",
                "libcutils",
                "libext2_uuid",
                "liblog",
                "liblz4",
                "libselinux",
                "libsparse",
            ],
        },
    },
}

cc_binary {
    name: "sload_f2fs",
    defaults: [
        "sload_f2fs_defaults",
    ],
    host_supported: true,
    target: {
        host: {
            static_libs: [
                "libbase",
                "libcrypto",
                "libcutils",
                "libext2_uuid",
                "liblog",
                "liblz4",
                "libselinux",
                "libsparse",
                "libz",
            ],
        },
    },
}

cc_binary {
    name: "sload_f2fs.recovery",
    defaults: [
        "sload_f2fs_defaults",
    ],
    recovery: true,
    stem: "sload_f2fs",
}

cc_binary {
    name: "check_f2fs",
    host_supported: false,
    cflags: [
        "--static",
        "-U_FORTIFY_SOURCE",
        "-Wall",
        "-Werror",
    ],
    srcs: ["tools/check_f2fs.c"],
    product_specific: true,
}

cc_defaults {
    name: "tools-defaults",
    cflags: [
        "-Wall",
        "-Werror",
    ],
    local_include_dirs: [
        "include",
    ],
    target: {
        windows: {
            enabled: false,
        },
        darwin: {
            enabled: false,
        },
    },
    product_specific: true,
}

cc_binary {
    name: "f2fscrypt",
    defaults: [
        "tools-defaults",
    ],
    shared_libs: [
        "libext2_uuid",
    ],
    srcs: [
        "tools/f2fscrypt.c",
        "tools/sha512.c",
    ],
}

cc_binary {
    name: "f2fs.fibmap",
    defaults: [
        "tools-defaults",
    ],
    srcs: [
        "tools/fibmap.c",
    ],
}