Merge "Native Side of Binder Proxy Tracking by Uid"
diff --git a/cmds/atrace/atrace.cpp b/cmds/atrace/atrace.cpp
index bce8b45..60be26f 100644
--- a/cmds/atrace/atrace.cpp
+++ b/cmds/atrace/atrace.cpp
@@ -258,6 +258,9 @@
static const char* k_printTgidPath =
"options/print-tgid";
+static const char* k_recordTgidPath =
+ "options/record-tgid";
+
static const char* k_funcgraphAbsTimePath =
"options/funcgraph-abstime";
@@ -520,9 +523,15 @@
static bool setPrintTgidEnableIfPresent(bool enable)
{
+ // Pre-4.13 this was options/print-tgid as an android-specific option.
+ // In 4.13+ this is an upstream option called options/record-tgid
+ // Both options produce the same ftrace format change
if (fileExists(k_printTgidPath)) {
return setKernelOptionEnable(k_printTgidPath, enable);
}
+ if (fileExists(k_recordTgidPath)) {
+ return setKernelOptionEnable(k_recordTgidPath, enable);
+ }
return true;
}
diff --git a/cmds/atrace/atrace.rc b/cmds/atrace/atrace.rc
index e978322..44cc410 100644
--- a/cmds/atrace/atrace.rc
+++ b/cmds/atrace/atrace.rc
@@ -19,6 +19,8 @@
chmod 0666 /sys/kernel/tracing/options/overwrite
chmod 0666 /sys/kernel/debug/tracing/options/print-tgid
chmod 0666 /sys/kernel/tracing/options/print-tgid
+ chmod 0666 /sys/kernel/debug/tracing/options/record-tgid
+ chmod 0666 /sys/kernel/tracing/options/record-tgid
chmod 0666 /sys/kernel/debug/tracing/saved_cmdlines_size
chmod 0666 /sys/kernel/tracing/saved_cmdlines_size
chmod 0666 /sys/kernel/debug/tracing/events/sched/sched_switch/enable
diff --git a/cmds/dumpstate/Android.bp b/cmds/dumpstate/Android.bp
index ce3a6aa..91109d9 100644
--- a/cmds/dumpstate/Android.bp
+++ b/cmds/dumpstate/Android.bp
@@ -87,6 +87,32 @@
"utils.cpp",
"dumpstate.cpp",
],
+ required: [
+ "atrace",
+ "df",
+ "getprop",
+ "ip",
+ "iptables",
+ "ip6tables",
+ "kill",
+ "librank",
+ "logcat",
+ "logcompressor",
+ "lsmod",
+ "lsof",
+ "netstat",
+ "parse_radio_log",
+ "printenv",
+ "procrank",
+ "screencap",
+ "showmap",
+ "ss",
+ "storaged",
+ "top",
+ "uptime",
+ "vdc",
+ "vril-dump",
+ ],
init_rc: ["dumpstate.rc"],
}
diff --git a/cmds/lshal/ListCommand.cpp b/cmds/lshal/ListCommand.cpp
index c0e1a35..7760a09 100644
--- a/cmds/lshal/ListCommand.cpp
+++ b/cmds/lshal/ListCommand.cpp
@@ -57,6 +57,19 @@
return (p == Partition::SYSTEM) ? vintf::SchemaType::FRAMEWORK : vintf::SchemaType::DEVICE;
}
+Partition toPartition(vintf::SchemaType t) {
+ switch (t) {
+ case vintf::SchemaType::FRAMEWORK: return Partition::SYSTEM;
+ // TODO(b/71555570): Device manifest does not distinguish HALs from vendor or ODM.
+ case vintf::SchemaType::DEVICE: return Partition::VENDOR;
+ }
+ return Partition::UNKNOWN;
+}
+
+std::string getPackageAndVersion(const std::string& fqInstance) {
+ return splitFirst(fqInstance, ':').first;
+}
+
NullableOStream<std::ostream> ListCommand::out() const {
return mLshal.out();
}
@@ -77,6 +90,8 @@
}
const std::string &ListCommand::getCmdline(pid_t pid) {
+ static const std::string kEmptyString{};
+ if (pid == NO_PID) return kEmptyString;
auto pair = mCmdlines.find(pid);
if (pair != mCmdlines.end()) {
return pair->second;
@@ -93,6 +108,7 @@
}
Partition ListCommand::getPartition(pid_t pid) {
+ if (pid == NO_PID) return Partition::UNKNOWN;
auto it = mPartitions.find(pid);
if (it != mPartitions.end()) {
return it->second;
@@ -176,7 +192,7 @@
FqInstance fqInstance;
if (!fqInstance.setTo(fqInstanceName) &&
// Ignore interface / instance for passthrough libs
- !fqInstance.setTo(splitFirst(fqInstanceName, ':').first)) {
+ !fqInstance.setTo(getPackageAndVersion(fqInstanceName))) {
err() << "Warning: Cannot parse '" << fqInstanceName << "'; no VINTF info." << std::endl;
return VINTF_INFO_EMPTY;
}
@@ -283,36 +299,39 @@
return &pair.first->second;
}
-bool ListCommand::shouldReportHalType(const HalType &type) const {
- return (std::find(mListTypes.begin(), mListTypes.end(), type) != mListTypes.end());
+bool ListCommand::shouldFetchHalType(const HalType &type) const {
+ return (std::find(mFetchTypes.begin(), mFetchTypes.end(), type) != mFetchTypes.end());
+}
+
+Table* ListCommand::tableForType(HalType type) {
+ switch (type) {
+ case HalType::BINDERIZED_SERVICES:
+ return &mServicesTable;
+ case HalType::PASSTHROUGH_CLIENTS:
+ return &mPassthroughRefTable;
+ case HalType::PASSTHROUGH_LIBRARIES:
+ return &mImplementationsTable;
+ case HalType::VINTF_MANIFEST:
+ return &mManifestHalsTable;
+ case HalType::LAZY_HALS:
+ return &mLazyHalsTable;
+ default:
+ LOG(FATAL) << "Unknown HAL type " << static_cast<int64_t>(type);
+ return nullptr;
+ }
+}
+const Table* ListCommand::tableForType(HalType type) const {
+ return const_cast<ListCommand*>(this)->tableForType(type);
}
void ListCommand::forEachTable(const std::function<void(Table &)> &f) {
for (const auto& type : mListTypes) {
- switch (type) {
- case HalType::BINDERIZED_SERVICES:
- f(mServicesTable); break;
- case HalType::PASSTHROUGH_CLIENTS:
- f(mPassthroughRefTable); break;
- case HalType::PASSTHROUGH_LIBRARIES:
- f(mImplementationsTable); break;
- default:
- LOG(FATAL) << __func__ << "Unknown HAL type.";
- }
+ f(*tableForType(type));
}
}
void ListCommand::forEachTable(const std::function<void(const Table &)> &f) const {
for (const auto& type : mListTypes) {
- switch (type) {
- case HalType::BINDERIZED_SERVICES:
- f(mServicesTable); break;
- case HalType::PASSTHROUGH_CLIENTS:
- f(mPassthroughRefTable); break;
- case HalType::PASSTHROUGH_LIBRARIES:
- f(mImplementationsTable); break;
- default:
- LOG(FATAL) << __func__ << "Unknown HAL type.";
- }
+ f(*tableForType(type));
}
}
@@ -329,7 +348,9 @@
}
}
for (TableEntry& entry : table) {
- entry.partition = getPartition(entry.serverPid);
+ if (entry.partition == Partition::UNKNOWN) {
+ entry.partition = getPartition(entry.serverPid);
+ }
entry.vintfInfo = getVintfInfo(entry.interfaceName, {entry.transport, entry.arch});
}
});
@@ -366,6 +387,12 @@
mImplementationsTable.setDescription(
"All available passthrough implementations (all -impl.so files).\n"
"These may return subclasses through their respective HIDL_FETCH_I* functions.");
+ mManifestHalsTable.setDescription(
+ "All HALs that are in VINTF manifest.");
+ mLazyHalsTable.setDescription(
+ "All HALs that are declared in VINTF manifest:\n"
+ " - as hwbinder HALs but are not registered to hwservicemanager, and\n"
+ " - as hwbinder/passthrough HALs with no implementation.");
}
bool ListCommand::addEntryWithInstance(const TableEntry& entry,
@@ -416,7 +443,7 @@
bool ListCommand::addEntryWithoutInstance(const TableEntry& entry,
const vintf::HalManifest* manifest) const {
- const auto& packageAndVersion = splitFirst(splitFirst(entry.interfaceName, ':').first, '@');
+ const auto& packageAndVersion = splitFirst(getPackageAndVersion(entry.interfaceName), '@');
const auto& package = packageAndVersion.first;
vintf::Version version;
if (!vintf::parse(packageAndVersion.second, &version)) {
@@ -446,6 +473,8 @@
if (!addEntryWithInstance(entry, &manifest)) error.push_back(entry.interfaceName);
for (const TableEntry& entry : mPassthroughRefTable)
if (!addEntryWithInstance(entry, &manifest)) error.push_back(entry.interfaceName);
+ for (const TableEntry& entry : mManifestHalsTable)
+ if (!addEntryWithInstance(entry, &manifest)) error.push_back(entry.interfaceName);
std::vector<std::string> passthrough;
for (const TableEntry& entry : mImplementationsTable)
@@ -503,8 +532,11 @@
void ListCommand::dumpTable(const NullableOStream<std::ostream>& out) const {
if (mNeat) {
- MergedTable({&mServicesTable, &mPassthroughRefTable, &mImplementationsTable})
- .createTextTable().dump(out.buf());
+ std::vector<const Table*> tables;
+ forEachTable([&tables](const Table &table) {
+ tables.push_back(&table);
+ });
+ MergedTable(std::move(tables)).createTextTable().dump(out.buf());
return;
}
@@ -552,25 +584,12 @@
return OK;
}
-void ListCommand::putEntry(TableEntrySource source, TableEntry &&entry) {
- Table *table = nullptr;
- switch (source) {
- case HWSERVICEMANAGER_LIST :
- table = &mServicesTable; break;
- case PTSERVICEMANAGER_REG_CLIENT :
- table = &mPassthroughRefTable; break;
- case LIST_DLLIB :
- table = &mImplementationsTable; break;
- default:
- err() << "Error: Unknown source of entry " << source << std::endl;
- }
- if (table) {
- table->add(std::forward<TableEntry>(entry));
- }
+void ListCommand::putEntry(HalType type, TableEntry &&entry) {
+ tableForType(type)->add(std::forward<TableEntry>(entry));
}
Status ListCommand::fetchAllLibraries(const sp<IServiceManager> &manager) {
- if (!shouldReportHalType(HalType::PASSTHROUGH_LIBRARIES)) { return OK; }
+ if (!shouldFetchHalType(HalType::PASSTHROUGH_LIBRARIES)) { return OK; }
using namespace ::android::hardware;
using namespace ::android::hidl::manager::V1_0;
@@ -588,7 +607,7 @@
}).first->second.arch |= fromBaseArchitecture(info.arch);
}
for (auto &&pair : entries) {
- putEntry(LIST_DLLIB, std::move(pair.second));
+ putEntry(HalType::PASSTHROUGH_LIBRARIES, std::move(pair.second));
}
});
if (!ret.isOk()) {
@@ -600,7 +619,7 @@
}
Status ListCommand::fetchPassthrough(const sp<IServiceManager> &manager) {
- if (!shouldReportHalType(HalType::PASSTHROUGH_CLIENTS)) { return OK; }
+ if (!shouldFetchHalType(HalType::PASSTHROUGH_CLIENTS)) { return OK; }
using namespace ::android::hardware;
using namespace ::android::hardware::details;
@@ -611,7 +630,7 @@
if (info.clientPids.size() <= 0) {
continue;
}
- putEntry(PTSERVICEMANAGER_REG_CLIENT, {
+ putEntry(HalType::PASSTHROUGH_CLIENTS, {
.interfaceName =
std::string{info.interfaceName.c_str()} + "/" +
std::string{info.instanceName.c_str()},
@@ -633,7 +652,7 @@
Status ListCommand::fetchBinderized(const sp<IServiceManager> &manager) {
using vintf::operator<<;
- if (!shouldReportHalType(HalType::BINDERIZED_SERVICES)) { return OK; }
+ if (!shouldFetchHalType(HalType::BINDERIZED_SERVICES)) { return OK; }
const vintf::Transport mode = vintf::Transport::HWBINDER;
hidl_vec<hidl_string> fqInstanceNames;
@@ -654,12 +673,13 @@
TableEntry& entry = allTableEntries[fqInstanceName];
entry.interfaceName = fqInstanceName;
entry.transport = mode;
+ entry.serviceStatus = ServiceStatus::NON_RESPONSIVE;
status |= fetchBinderizedEntry(manager, &entry);
}
for (auto& pair : allTableEntries) {
- putEntry(HWSERVICEMANAGER_LIST, std::move(pair.second));
+ putEntry(HalType::BINDERIZED_SERVICES, std::move(pair.second));
}
return status;
}
@@ -759,9 +779,100 @@
handleError(TRANSACTION_ERROR, "getHashChain failed: " + hashRet.description());
}
} while (0);
+ if (status == OK) {
+ entry->serviceStatus = ServiceStatus::ALIVE;
+ }
return status;
}
+Status ListCommand::fetchManifestHals() {
+ if (!shouldFetchHalType(HalType::VINTF_MANIFEST)) { return OK; }
+ Status status = OK;
+
+ for (auto manifest : {getDeviceManifest(), getFrameworkManifest()}) {
+ if (manifest == nullptr) {
+ status |= VINTF_ERROR;
+ continue;
+ }
+
+ std::map<std::string, TableEntry> entries;
+
+ manifest->forEachInstance([&] (const vintf::ManifestInstance& manifestInstance) {
+ TableEntry entry{
+ .interfaceName = manifestInstance.getFqInstance().string(),
+ .transport = manifestInstance.transport(),
+ .arch = manifestInstance.arch(),
+ // TODO(b/71555570): Device manifest does not distinguish HALs from vendor or ODM.
+ .partition = toPartition(manifest->type()),
+ .serviceStatus = ServiceStatus::DECLARED};
+ std::string key = entry.interfaceName;
+ entries.emplace(std::move(key), std::move(entry));
+ return true;
+ });
+
+ for (auto&& pair : entries)
+ mManifestHalsTable.add(std::move(pair.second));
+ }
+ return status;
+}
+
+Status ListCommand::fetchLazyHals() {
+ using vintf::operator<<;
+
+ if (!shouldFetchHalType(HalType::LAZY_HALS)) { return OK; }
+ Status status = OK;
+
+ for (const TableEntry& manifestEntry : mManifestHalsTable) {
+ if (manifestEntry.transport == vintf::Transport::HWBINDER) {
+ if (!hasHwbinderEntry(manifestEntry)) {
+ mLazyHalsTable.add(TableEntry(manifestEntry));
+ }
+ continue;
+ }
+ if (manifestEntry.transport == vintf::Transport::PASSTHROUGH) {
+ if (!hasPassthroughEntry(manifestEntry)) {
+ mLazyHalsTable.add(TableEntry(manifestEntry));
+ }
+ continue;
+ }
+ err() << "Warning: unrecognized transport in VINTF manifest: "
+ << manifestEntry.transport;
+ status |= VINTF_ERROR;
+ }
+ return status;
+}
+
+bool ListCommand::hasHwbinderEntry(const TableEntry& entry) const {
+ for (const TableEntry& existing : mServicesTable) {
+ if (existing.interfaceName == entry.interfaceName) {
+ return true;
+ }
+ }
+ return false;
+}
+
+bool ListCommand::hasPassthroughEntry(const TableEntry& entry) const {
+ FqInstance entryFqInstance;
+ if (!entryFqInstance.setTo(entry.interfaceName)) {
+ return false; // cannot parse, so add it anyway.
+ }
+ for (const TableEntry& existing : mImplementationsTable) {
+ FqInstance existingFqInstance;
+ if (!existingFqInstance.setTo(getPackageAndVersion(existing.interfaceName))) {
+ continue;
+ }
+
+ // For example, manifest may say graphics.mapper@2.1 but passthroughServiceManager
+ // can only list graphics.mapper@2.0.
+ if (entryFqInstance.getPackage() == existingFqInstance.getPackage() &&
+ vintf::Version{entryFqInstance.getVersion()}
+ .minorAtLeast(vintf::Version{existingFqInstance.getVersion()})) {
+ return true;
+ }
+ }
+ return false;
+}
+
Status ListCommand::fetch() {
Status status = OK;
auto bManager = mLshal.serviceManager();
@@ -781,9 +892,27 @@
} else {
status |= fetchAllLibraries(pManager);
}
+ status |= fetchManifestHals();
+ status |= fetchLazyHals();
return status;
}
+void ListCommand::initFetchTypes() {
+ // TODO: refactor to do polymorphism on each table (so that dependency graph is not hardcoded).
+ static const std::map<HalType, std::set<HalType>> kDependencyGraph{
+ {HalType::LAZY_HALS, {HalType::BINDERIZED_SERVICES,
+ HalType::PASSTHROUGH_LIBRARIES,
+ HalType::VINTF_MANIFEST}},
+ };
+ mFetchTypes.insert(mListTypes.begin(), mListTypes.end());
+ for (HalType listType : mListTypes) {
+ auto it = kDependencyGraph.find(listType);
+ if (it != kDependencyGraph.end()) {
+ mFetchTypes.insert(it->second.begin(), it->second.end());
+ }
+ }
+}
+
void ListCommand::registerAllOptions() {
int v = mOptions.size();
// A list of acceptable command line options
@@ -847,6 +976,14 @@
" - DC: device compatibility matrix\n"
" - FM: framework manifest\n"
" - FC: framework compatibility matrix"});
+ mOptions.push_back({'S', "service-status", no_argument, v++, [](ListCommand* thiz, const char*) {
+ thiz->mSelectedColumns.push_back(TableColumnType::SERVICE_STATUS);
+ return OK;
+ }, "print service status column. Possible values are:\n"
+ " - alive: alive and running hwbinder service;\n"
+ " - registered;dead: registered to hwservicemanager but is not responsive;\n"
+ " - declared: only declared in VINTF manifest but is not registered to hwservicemanager;\n"
+ " - N/A: no information for passthrough HALs."});
// long options without short alternatives
mOptions.push_back({'\0', "init-vintf", no_argument, v++, [](ListCommand* thiz, const char* arg) {
@@ -887,7 +1024,11 @@
{"passthrough_clients", HalType::PASSTHROUGH_CLIENTS},
{"c", HalType::PASSTHROUGH_CLIENTS},
{"passthrough_libs", HalType::PASSTHROUGH_LIBRARIES},
- {"l", HalType::PASSTHROUGH_LIBRARIES}
+ {"l", HalType::PASSTHROUGH_LIBRARIES},
+ {"vintf", HalType::VINTF_MANIFEST},
+ {"v", HalType::VINTF_MANIFEST},
+ {"lazy", HalType::LAZY_HALS},
+ {"z", HalType::LAZY_HALS},
};
std::vector<std::string> halTypesArgs = split(std::string(arg), ',');
@@ -911,9 +1052,9 @@
if (thiz->mListTypes.empty()) { return USAGE; }
return OK;
- }, "comma-separated list of one or more HAL types.\nThe output is restricted to the selected "
- "association(s). Valid options\nare: (b|binderized), (c|passthrough_clients), and (l|"
- "passthrough_libs).\nBy default, lists all available HALs."});
+ }, "comma-separated list of one or more sections.\nThe output is restricted to the selected "
+ "section(s). Valid options\nare: (b|binderized), (c|passthrough_clients), (l|"
+ "passthrough_libs), and (v|vintf).\nDefault is `bcl`."});
}
// Create 'longopts' argument to getopt_long. Caller is responsible for maintaining
@@ -1030,6 +1171,7 @@
mListTypes = {HalType::BINDERIZED_SERVICES, HalType::PASSTHROUGH_CLIENTS,
HalType::PASSTHROUGH_LIBRARIES};
}
+ initFetchTypes();
forEachTable([this] (Table& table) {
table.setSelectedColumns(this->mSelectedColumns);
@@ -1068,7 +1210,7 @@
err() << "list:" << std::endl
<< " lshal" << std::endl
<< " lshal list" << std::endl
- << " List all hals with default ordering and columns (`lshal list -riepc`)" << std::endl
+ << " List all hals with default ordering and columns (`lshal list -liepc`)" << std::endl
<< " lshal list [-h|--help]" << std::endl
<< " -h, --help: Print help message for list (`lshal help list`)" << std::endl
<< " lshal [list] [OPTIONS...]" << std::endl;
diff --git a/cmds/lshal/ListCommand.h b/cmds/lshal/ListCommand.h
index 87d93b5..3f7321d 100644
--- a/cmds/lshal/ListCommand.h
+++ b/cmds/lshal/ListCommand.h
@@ -50,7 +50,9 @@
enum class HalType {
BINDERIZED_SERVICES = 0,
PASSTHROUGH_CLIENTS,
- PASSTHROUGH_LIBRARIES
+ PASSTHROUGH_LIBRARIES,
+ VINTF_MANIFEST,
+ LAZY_HALS,
};
class ListCommand : public Command {
@@ -93,10 +95,12 @@
// Retrieve derived information base on existing table
virtual void postprocess();
Status dump();
- void putEntry(TableEntrySource source, TableEntry &&entry);
+ void putEntry(HalType type, TableEntry &&entry);
Status fetchPassthrough(const sp<::android::hidl::manager::V1_0::IServiceManager> &manager);
Status fetchBinderized(const sp<::android::hidl::manager::V1_0::IServiceManager> &manager);
Status fetchAllLibraries(const sp<::android::hidl::manager::V1_0::IServiceManager> &manager);
+ Status fetchManifestHals();
+ Status fetchLazyHals();
Status fetchBinderizedEntry(const sp<::android::hidl::manager::V1_0::IServiceManager> &manager,
TableEntry *entry);
@@ -134,6 +138,8 @@
void forEachTable(const std::function<void(Table &)> &f);
void forEachTable(const std::function<void(const Table &)> &f) const;
+ Table* tableForType(HalType type);
+ const Table* tableForType(HalType type) const;
NullableOStream<std::ostream> err() const;
NullableOStream<std::ostream> out() const;
@@ -144,12 +150,20 @@
bool addEntryWithInstance(const TableEntry &entry, vintf::HalManifest *manifest) const;
bool addEntryWithoutInstance(const TableEntry &entry, const vintf::HalManifest *manifest) const;
- // Helper function. Whether to list entries corresponding to a given HAL type.
- bool shouldReportHalType(const HalType &type) const;
+ // Helper function. Whether to fetch entries corresponding to a given HAL type.
+ bool shouldFetchHalType(const HalType &type) const;
+
+ void initFetchTypes();
+
+ // Helper functions ti add HALs that are listed in VINTF manifest to LAZY_HALS table.
+ bool hasHwbinderEntry(const TableEntry& entry) const;
+ bool hasPassthroughEntry(const TableEntry& entry) const;
Table mServicesTable{};
Table mPassthroughRefTable{};
Table mImplementationsTable{};
+ Table mManifestHalsTable{};
+ Table mLazyHalsTable{};
std::string mFileOutputPath;
TableEntryCompare mSortColumn = nullptr;
@@ -163,9 +177,10 @@
// If true, explanatory text are not emitted.
bool mNeat = false;
- // Type(s) of HAL associations to list. By default, report all.
- std::vector<HalType> mListTypes{HalType::BINDERIZED_SERVICES, HalType::PASSTHROUGH_CLIENTS,
- HalType::PASSTHROUGH_LIBRARIES};
+ // Type(s) of HAL associations to list.
+ std::vector<HalType> mListTypes{};
+ // Type(s) of HAL associations to fetch.
+ std::set<HalType> mFetchTypes{};
// If an entry does not exist, need to ask /proc/{pid}/cmdline to get it.
// If an entry exist but is an empty string, process might have died.
diff --git a/cmds/lshal/TableEntry.cpp b/cmds/lshal/TableEntry.cpp
index 4ad3e92..8e21975 100644
--- a/cmds/lshal/TableEntry.cpp
+++ b/cmds/lshal/TableEntry.cpp
@@ -62,6 +62,7 @@
case TableColumnType::RELEASED: return "R";
case TableColumnType::HASH: return "Hash";
case TableColumnType::VINTF: return "VINTF";
+ case TableColumnType::SERVICE_STATUS: return "Status";
default:
LOG(FATAL) << __func__ << "Should not reach here. " << static_cast<int>(type);
return "";
@@ -94,6 +95,8 @@
return hash;
case TableColumnType::VINTF:
return getVintfInfo();
+ case TableColumnType::SERVICE_STATUS:
+ return lshal::to_string(serviceStatus);
default:
LOG(FATAL) << __func__ << "Should not reach here. " << static_cast<int>(type);
return "";
@@ -129,6 +132,18 @@
return joined.empty() ? "X" : joined;
}
+std::string to_string(ServiceStatus s) {
+ switch (s) {
+ case ServiceStatus::ALIVE: return "alive";
+ case ServiceStatus::NON_RESPONSIVE: return "non-responsive";
+ case ServiceStatus::DECLARED: return "declared";
+ case ServiceStatus::UNKNOWN: return "N/A";
+ }
+
+ LOG(FATAL) << __func__ << "Should not reach here." << static_cast<int>(s);
+ return "";
+}
+
TextTable Table::createTextTable(bool neat,
const std::function<std::string(const std::string&)>& emitDebugInfo) const {
diff --git a/cmds/lshal/TableEntry.h b/cmds/lshal/TableEntry.h
index c9a6a23..7294b0a 100644
--- a/cmds/lshal/TableEntry.h
+++ b/cmds/lshal/TableEntry.h
@@ -35,13 +35,6 @@
using android::procpartition::Partition;
using Pids = std::vector<int32_t>;
-enum : unsigned int {
- HWSERVICEMANAGER_LIST, // through defaultServiceManager()->list()
- PTSERVICEMANAGER_REG_CLIENT, // through registerPassthroughClient
- LIST_DLLIB, // through listing dynamic libraries
-};
-using TableEntrySource = unsigned int;
-
enum class TableColumnType : unsigned int {
INTERFACE_NAME,
TRANSPORT,
@@ -55,6 +48,7 @@
RELEASED,
HASH,
VINTF,
+ SERVICE_STATUS,
};
enum : unsigned int {
@@ -71,6 +65,14 @@
NO_PTR = 0
};
+enum class ServiceStatus {
+ UNKNOWN, // For passthrough
+ ALIVE,
+ NON_RESPONSIVE, // registered but not respond to calls
+ DECLARED, // in VINTF manifest
+};
+std::string to_string(ServiceStatus s);
+
struct TableEntry {
std::string interfaceName{};
vintf::Transport transport{vintf::Transport::EMPTY};
@@ -86,6 +88,8 @@
std::string hash{};
Partition partition{Partition::UNKNOWN};
VintfInfo vintfInfo{VINTF_INFO_EMPTY};
+ // true iff hwbinder and service started
+ ServiceStatus serviceStatus{ServiceStatus::UNKNOWN};
static bool sortByInterfaceName(const TableEntry &a, const TableEntry &b) {
return a.interfaceName < b.interfaceName;
diff --git a/cmds/lshal/test.cpp b/cmds/lshal/test.cpp
index 501c04d..8d7405b 100644
--- a/cmds/lshal/test.cpp
+++ b/cmds/lshal/test.cpp
@@ -226,12 +226,13 @@
void SetUp() override {
mockLshal = std::make_unique<NiceMock<MockLshal>>();
mockList = std::make_unique<MockListCommand>(mockLshal.get());
+ ON_CALL(*mockLshal, err()).WillByDefault(Return(NullableOStream<std::ostream>(err)));
// ListCommand::parseArgs should parse arguments from the second element
optind = 1;
}
std::unique_ptr<MockLshal> mockLshal;
std::unique_ptr<MockListCommand> mockList;
- std::stringstream output;
+ std::stringstream err;
};
TEST_F(ListParseArgsTest, Args) {
@@ -241,6 +242,7 @@
TableColumnType::SERVER_ADDR, TableColumnType::CLIENT_PIDS}),
table.getSelectedColumns());
});
+ EXPECT_EQ("", err.str());
}
TEST_F(ListParseArgsTest, Cmds) {
@@ -255,12 +257,12 @@
EXPECT_THAT(table.getSelectedColumns(), Contains(TableColumnType::CLIENT_CMDS))
<< "should print client cmds with -m";
});
+ EXPECT_EQ("", err.str());
}
TEST_F(ListParseArgsTest, DebugAndNeat) {
- ON_CALL(*mockLshal, err()).WillByDefault(Return(NullableOStream<std::ostream>(output)));
EXPECT_NE(0u, mockList->parseArgs(createArg({"lshal", "--neat", "-d"})));
- EXPECT_THAT(output.str(), StrNe(""));
+ EXPECT_THAT(err.str(), HasSubstr("--neat should not be used with --debug."));
}
/// Fetch Test
@@ -325,7 +327,7 @@
class ListTest : public ::testing::Test {
public:
- void SetUp() override {
+ virtual void SetUp() override {
initMockServiceManager();
lshal = std::make_unique<Lshal>(out, err, serviceManager, passthruManager);
initMockList();
@@ -349,13 +351,13 @@
ON_CALL(*mockList, getPartition(_)).WillByDefault(Return(Partition::VENDOR));
ON_CALL(*mockList, getDeviceManifest())
- .WillByDefault(Return(VintfObject::GetDeviceHalManifest()));
+ .WillByDefault(Return(std::make_shared<HalManifest>()));
ON_CALL(*mockList, getDeviceMatrix())
- .WillByDefault(Return(VintfObject::GetDeviceCompatibilityMatrix()));
+ .WillByDefault(Return(std::make_shared<CompatibilityMatrix>()));
ON_CALL(*mockList, getFrameworkManifest())
- .WillByDefault(Return(VintfObject::GetFrameworkHalManifest()));
+ .WillByDefault(Return(std::make_shared<HalManifest>()));
ON_CALL(*mockList, getFrameworkMatrix())
- .WillByDefault(Return(VintfObject::GetFrameworkCompatibilityMatrix()));
+ .WillByDefault(Return(std::make_shared<CompatibilityMatrix>()));
}
void initMockServiceManager() {
@@ -409,16 +411,22 @@
}
TEST_F(ListTest, Fetch) {
- EXPECT_EQ(0u, mockList->fetch());
+ optind = 1; // mimic Lshal::parseArg()
+ ASSERT_EQ(0u, mockList->parseArgs(createArg({"lshal"})));
+ ASSERT_EQ(0u, mockList->fetch());
vintf::TransportArch hwbinder{Transport::HWBINDER, Arch::ARCH_64};
vintf::TransportArch passthrough{Transport::PASSTHROUGH, Arch::ARCH_32};
std::array<vintf::TransportArch, 6> transportArchs{{hwbinder, hwbinder, passthrough,
passthrough, passthrough, passthrough}};
- int id = 1;
+ int i = 0;
mockList->forEachTable([&](const Table& table) {
- ASSERT_EQ(2u, table.size());
for (const auto& entry : table) {
- auto transport = transportArchs.at(id - 1).transport;
+ if (i >= transportArchs.size()) {
+ break;
+ }
+
+ int id = i + 1;
+ auto transport = transportArchs.at(i).transport;
TableEntry expected{
.interfaceName = getFqInstanceName(id),
.transport = transport,
@@ -431,14 +439,16 @@
.serverObjectAddress = transport == Transport::HWBINDER ? getPtr(id) : NO_PTR,
.clientPids = getClients(id),
.clientCmdlines = {},
- .arch = transportArchs.at(id - 1).arch,
+ .arch = transportArchs.at(i).arch,
};
EXPECT_EQ(expected, entry) << expected.to_string() << " vs. " << entry.to_string();
- ++id;
+ ++i;
}
});
+ EXPECT_EQ(transportArchs.size(), i) << "Not all entries are tested.";
+
}
TEST_F(ListTest, DumpVintf) {
@@ -756,6 +766,60 @@
EXPECT_EQ("", err.str());
}
+class ListVintfTest : public ListTest {
+public:
+ virtual void SetUp() override {
+ ListTest::SetUp();
+ const std::string mockManifestXml =
+ "<manifest version=\"1.0\" type=\"device\">\n"
+ " <hal format=\"hidl\">\n"
+ " <name>a.h.foo1</name>\n"
+ " <transport>hwbinder</transport>\n"
+ " <fqname>@1.0::IFoo/1</fqname>\n"
+ " </hal>\n"
+ " <hal format=\"hidl\">\n"
+ " <name>a.h.bar1</name>\n"
+ " <transport>hwbinder</transport>\n"
+ " <fqname>@1.0::IBar/1</fqname>\n"
+ " </hal>\n"
+ " <hal format=\"hidl\">\n"
+ " <name>a.h.bar2</name>\n"
+ " <transport arch=\"32+64\">passthrough</transport>\n"
+ " <fqname>@2.0::IBar/2</fqname>\n"
+ " </hal>\n"
+ "</manifest>";
+ auto manifest = std::make_shared<HalManifest>();
+ EXPECT_TRUE(gHalManifestConverter(manifest.get(), mockManifestXml));
+ EXPECT_CALL(*mockList, getDeviceManifest())
+ .Times(AnyNumber())
+ .WillRepeatedly(Return(manifest));
+ }
+};
+
+TEST_F(ListVintfTest, ManifestHals) {
+ optind = 1; // mimic Lshal::parseArg()
+ EXPECT_EQ(0u, mockList->main(createArg({"lshal", "-iStr", "--types=v", "--neat"})));
+ EXPECT_THAT(out.str(), HasSubstr("a.h.bar1@1.0::IBar/1 declared hwbinder ?"));
+ EXPECT_THAT(out.str(), HasSubstr("a.h.bar2@2.0::IBar/2 declared passthrough 32+64"));
+ EXPECT_THAT(out.str(), HasSubstr("a.h.foo1@1.0::IFoo/1 declared hwbinder ?"));
+ EXPECT_EQ("", err.str());
+}
+
+TEST_F(ListVintfTest, Lazy) {
+ optind = 1; // mimic Lshal::parseArg()
+ EXPECT_EQ(0u, mockList->main(createArg({"lshal", "-iStr", "--types=z", "--neat"})));
+ EXPECT_THAT(out.str(), HasSubstr("a.h.bar1@1.0::IBar/1 declared hwbinder ?"));
+ EXPECT_THAT(out.str(), HasSubstr("a.h.bar2@2.0::IBar/2 declared passthrough 32+64"));
+ EXPECT_EQ("", err.str());
+}
+
+TEST_F(ListVintfTest, NoLazy) {
+ optind = 1; // mimic Lshal::parseArg()
+ EXPECT_EQ(0u, mockList->main(createArg({"lshal", "-iStr", "--types=b,c,l", "--neat"})));
+ EXPECT_THAT(out.str(), Not(HasSubstr("IBar")));
+ EXPECT_EQ("", err.str());
+}
+
class HelpTest : public ::testing::Test {
public:
void SetUp() override {
diff --git a/cmds/lshal/utils.h b/cmds/lshal/utils.h
index c09e8b1..240155e 100644
--- a/cmds/lshal/utils.h
+++ b/cmds/lshal/utils.h
@@ -46,6 +46,8 @@
TRANSACTION_ERROR = 1 << 8,
// No transaction error, but return value is unexpected.
BAD_IMPL = 1 << 9,
+ // Cannot fetch VINTF data.
+ VINTF_ERROR = 1 << 10,
};
using Status = unsigned int;
diff --git a/data/etc/android.hardware.usb.accessory.xml b/data/etc/android.hardware.usb.accessory.xml
index 80a0904..29df966 100644
--- a/data/etc/android.hardware.usb.accessory.xml
+++ b/data/etc/android.hardware.usb.accessory.xml
@@ -17,6 +17,4 @@
<!-- This is the standard feature indicating that the device supports USB accessories. -->
<permissions>
<feature name="android.hardware.usb.accessory" />
- <library name="com.android.future.usb.accessory"
- file="/system/framework/com.android.future.usb.accessory.jar" />
</permissions>
diff --git a/libs/binder/ProcessState.cpp b/libs/binder/ProcessState.cpp
index 3e871f8..53f8ddd 100644
--- a/libs/binder/ProcessState.cpp
+++ b/libs/binder/ProcessState.cpp
@@ -43,6 +43,12 @@
#define BINDER_VM_SIZE ((1 * 1024 * 1024) - sysconf(_SC_PAGE_SIZE) * 2)
#define DEFAULT_MAX_BINDER_THREADS 15
+#ifdef __ANDROID_VNDK__
+const char* kDefaultDriver = "/dev/vndbinder";
+#else
+const char* kDefaultDriver = "/dev/binder";
+#endif
+
// -------------------------------------------------------------------------
namespace android {
@@ -71,7 +77,7 @@
if (gProcess != nullptr) {
return gProcess;
}
- gProcess = new ProcessState("/dev/binder");
+ gProcess = new ProcessState(kDefaultDriver);
return gProcess;
}
diff --git a/libs/binder/include/binder/ProcessState.h b/libs/binder/include/binder/ProcessState.h
index f85c261..13f67ba 100644
--- a/libs/binder/include/binder/ProcessState.h
+++ b/libs/binder/include/binder/ProcessState.h
@@ -36,9 +36,12 @@
public:
static sp<ProcessState> self();
static sp<ProcessState> selfOrNull();
+
/* initWithDriver() can be used to configure libbinder to use
* a different binder driver dev node. It must be called *before*
- * any call to ProcessState::self(). /dev/binder remains the default.
+ * any call to ProcessState::self(). The default is /dev/vndbinder
+ * for processes built with the VNDK and /dev/binder for those
+ * which are not.
*/
static sp<ProcessState> initWithDriver(const char *driver);
diff --git a/vulkan/api/vulkan.api b/vulkan/api/vulkan.api
index 832a8e9..e36b7bc 100644
--- a/vulkan/api/vulkan.api
+++ b/vulkan/api/vulkan.api
@@ -28,7 +28,7 @@
// API version (major.minor.patch)
define VERSION_MAJOR 1
define VERSION_MINOR 1
-define VERSION_PATCH 76
+define VERSION_PATCH 80
// API limits
define VK_MAX_PHYSICAL_DEVICE_NAME_SIZE 256
@@ -269,6 +269,10 @@
@extension("VK_KHR_push_descriptor") define VK_KHR_PUSH_DESCRIPTOR_SPEC_VERSION 2
@extension("VK_KHR_push_descriptor") define VK_KHR_PUSH_DESCRIPTOR_EXTENSION_NAME "VK_KHR_push_descriptor"
+// 82
+@extension("VK_EXT_conditional_rendering") define VK_EXT_CONDITIONAL_RENDERING_SPEC_VERSION 1
+@extension("VK_EXT_conditional_rendering") define VK_EXT_CONDITIONAL_RENDERING_EXTENSION_NAME "VK_EXT_conditional_rendering"
+
// 84
@extension("VK_KHR_16bit_storage") define VK_KHR_16BIT_STORAGE_SPEC_VERSION 1
@extension("VK_KHR_16bit_storage") define VK_KHR_16BIT_STORAGE_EXTENSION_NAME "VK_KHR_16bit_storage"
@@ -345,6 +349,10 @@
@extension("VK_EXT_hdr_metadata") define VK_EXT_HDR_METADATA_SPEC_VERSION 1
@extension("VK_EXT_hdr_metadata") define VK_EXT_HDR_METADATA_EXTENSION_NAME "VK_EXT_hdr_metadata"
+// 110
+@extension("VK_KHR_create_renderpass2") define VK_KHR_CREATE_RENDERPASS2_SPEC_VERSION 1
+@extension("VK_KHR_create_renderpass2") define VK_KHR_CREATE_RENDERPASS2_EXTENSION_NAME "VK_KHR_create_renderpass2"
+
// 112
@extension("VK_KHR_shared_presentable_image") define VK_KHR_SHARED_PRESENTABLE_IMAGE_SPEC_VERSION 1
@extension("VK_KHR_shared_presentable_image") define VK_KHR_SHARED_PRESENTABLE_IMAGE_EXTENSION_NAME "VK_KHR_shared_presentable_image"
@@ -501,6 +509,10 @@
@extension("VK_EXT_global_priority") define VK_EXT_GLOBAL_PRIORITY_SPEC_VERSION 1
@extension("VK_EXT_global_priority") define VK_EXT_GLOBAL_PRIORITY_EXTENSION_NAME "VK_EXT_global_priority"
+// 178
+@extension("VK_KHR_8bit_storage") define VK_KHR_8BIT_STORAGE_SPEC_VERSION 1
+@extension("VK_KHR_8bit_storage") define VK_KHR_8BIT_STORAGE_EXTENSION_NAME "VK_KHR_8bit_storage"
+
// 179
@extension("VK_EXT_external_memory_host") define VK_EXT_EXTERNAL_MEMORY_HOST_SPEC_VERSION 1
@extension("VK_EXT_external_memory_host") define VK_EXT_EXTERNAL_MEMORY_HOST_EXTENSION_NAME "VK_EXT_external_memory_host"
@@ -1453,6 +1465,11 @@
//@extension("VK_KHR_incremental_present") // 85
VK_STRUCTURE_TYPE_PRESENT_REGIONS_KHR = 1000084000,
+ //@extension("VK_EXT_conditional_rendering") // 82
+ VK_STRUCTURE_TYPE_COMMAND_BUFFER_INHERITANCE_CONDITIONAL_RENDERING_INFO_EXT = 1000081000,
+ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CONDITIONAL_RENDERING_FEATURES_EXT = 1000081001,
+ VK_STRUCTURE_TYPE_CONDITIONAL_RENDERING_BEGIN_INFO_EXT = 1000081002,
+
//@extension("VK_KHR_descriptor_update_template") // 86
VK_STRUCTURE_TYPE_DESCRIPTOR_UPDATE_TEMPLATE_CREATE_INFO_KHR = 1000085000,
@@ -1493,6 +1510,15 @@
VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CONSERVATIVE_RASTERIZATION_PROPERTIES_EXT = 1000101000,
VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_CONSERVATIVE_STATE_CREATE_INFO_EXT = 1000101001,
+ //@extension("VK_KHR_create_renderpass2") // 110
+ VK_STRUCTURE_TYPE_ATTACHMENT_DESCRIPTION_2_KHR = 1000109000,
+ VK_STRUCTURE_TYPE_ATTACHMENT_REFERENCE_2_KHR = 1000109001,
+ VK_STRUCTURE_TYPE_SUBPASS_DESCRIPTION_2_KHR = 1000109002,
+ VK_STRUCTURE_TYPE_SUBPASS_DEPENDENCY_2_KHR = 1000109003,
+ VK_STRUCTURE_TYPE_RENDER_PASS_CREATE_INFO_2_KHR = 1000109004,
+ VK_STRUCTURE_TYPE_SUBPASS_BEGIN_INFO_KHR = 1000109005,
+ VK_STRUCTURE_TYPE_SUBPASS_END_INFO_KHR = 1000109006,
+
//@extension("VK_EXT_hdr_metadata") // 106
VK_STRUCTURE_TYPE_HDR_METADATA_EXT = 1000105000,
@@ -1623,6 +1649,9 @@
//@extension("VK_EXT_global_priority") // 175
VK_STRUCTURE_TYPE_DEVICE_QUEUE_GLOBAL_PRIORITY_CREATE_INFO_EXT = 1000174000,
+ //@extension("VK_KHR_8bit_storage") // 178
+ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_8BIT_STORAGE_FEATURES_KHR = 1000177000,
+
//@extension("VK_EXT_external_memory_host") // 179
VK_STRUCTURE_TYPE_IMPORT_MEMORY_HOST_POINTER_INFO_EXT = 1000178000,
VK_STRUCTURE_TYPE_MEMORY_HOST_POINTER_PROPERTIES_EXT = 1000178001,
@@ -1825,6 +1854,12 @@
VK_DESCRIPTOR_UPDATE_TEMPLATE_TYPE_PUSH_DESCRIPTORS_KHR = 1,
}
+enum VkVendorId {
+ VK_VENDOR_ID_VIV = 0x10001,
+ VK_VENDOR_ID_VSI = 0x10002,
+ VK_VENDOR_ID_KAZAN = 0x10003,
+}
+
@extension("VK_KHR_surface") // 1
enum VkPresentModeKHR {
VK_PRESENT_MODE_IMMEDIATE_KHR = 0x00000000,
@@ -2128,6 +2163,9 @@
//@extension("VK_EXT_blend_operation_advanced") // 149
VK_ACCESS_COLOR_ATTACHMENT_READ_NONCOHERENT_BIT_EXT = 0x00080000,
+
+ //@extension("VK_EXT_conditional_rendering") // 82
+ VK_ACCESS_CONDITIONAL_RENDERING_READ_BIT_EXT = 0x00100000,
}
/// Buffer usage flags
@@ -2142,6 +2180,9 @@
VK_BUFFER_USAGE_INDEX_BUFFER_BIT = 0x00000040, /// Can be used as source of fixed function index fetch (index buffer)
VK_BUFFER_USAGE_VERTEX_BUFFER_BIT = 0x00000080, /// Can be used as source of fixed function vertex fetch (VBO)
VK_BUFFER_USAGE_INDIRECT_BUFFER_BIT = 0x00000100, /// Can be the source of indirect parameters (e.g. indirect buffer, parameter buffer)
+
+ //@extension("VK_EXT_conditional_rendering") // 82
+ VK_BUFFER_USAGE_CONDITIONAL_RENDERING_BIT_EXT = 0x00000200,
}
/// Buffer creation flags
@@ -2434,6 +2475,9 @@
//@extension("VK_NVX_device_generated_commands") // 87
VK_PIPELINE_STAGE_COMMAND_PROCESS_BIT_NVX = 0x00020000,
+
+ //@extension("VK_EXT_conditional_rendering") // 82
+ VK_PIPELINE_STAGE_CONDITIONAL_RENDERING_BIT_EXT = 0x00040000,
}
/// Render pass attachment description flags
@@ -2960,6 +3004,13 @@
VK_SEMAPHORE_IMPORT_TEMPORARY_BIT_KHR = 0x00000001,
}
+@extension("VK_EXT_conditional_rendering") // 82
+type VkFlags VkConditionalRenderingFlagsEXT
+@extension("VK_EXT_conditional_rendering") // 82
+bitfield VkConditionalRenderingFlagBitsEXT {
+ VK_CONDITIONAL_RENDERING_INVERTED_BIT_EXT = 0x00000001,
+}
+
@extension("VK_KHR_descriptor_update_template") // 86
type VkFlags VkDescriptorUpdateTemplateCreateFlagsKHR
//@extension("VK_KHR_descriptor_update_template") // 86
@@ -5536,6 +5587,30 @@
u32 maxPushDescriptors
}
+@extension("VK_EXT_conditional_rendering") // 82
+class VkConditionalRenderingBeginInfoEXT {
+ VkStructureType sType
+ const void* pNext
+ VkBuffer buffer
+ VkDeviceSize offset
+ VkConditionalRenderingFlagsEXT flags
+}
+
+@extension("VK_EXT_conditional_rendering") // 82
+class VkPhysicalDeviceConditionalRenderingFeaturesEXT {
+ VkStructureType sType
+ void* pNext
+ VkBool32 conditionalRendering
+ VkBool32 inheritedConditionalRendering
+}
+
+@extension("VK_EXT_conditional_rendering") // 82
+class VkCommandBufferInheritanceConditionalRenderingInfoEXT {
+ VkStructureType sType
+ const void* pNext
+ VkBool32 conditionalRenderingEnable
+}
+
@extension("VK_KHR_16bit_storage") // 84
class VkPhysicalDevice16BitStorageFeaturesKHR {
VkStructureType sType
@@ -5891,6 +5966,89 @@
f32 maxFrameAverageLightLevel
}
+@extension("VK_KHR_create_renderpass2") // 110
+class VkAttachmentDescription2KHR {
+ VkStructureType sType
+ const void* pNext
+ VkAttachmentDescriptionFlags flags
+ VkFormat format
+ VkSampleCountFlagBits samples
+ VkAttachmentLoadOp loadOp
+ VkAttachmentStoreOp storeOp
+ VkAttachmentLoadOp stencilLoadOp
+ VkAttachmentStoreOp stencilStoreOp
+ VkImageLayout initialLayout
+ VkImageLayout finalLayout
+}
+
+@extension("VK_KHR_create_renderpass2") // 110
+class VkAttachmentReference2KHR {
+ VkStructureType sType
+ const void* pNext
+ u32 attachment
+ VkImageLayout layout
+ VkImageAspectFlags aspectMask
+}
+
+@extension("VK_KHR_create_renderpass2") // 110
+class VkSubpassDescription2KHR {
+ VkStructureType sType
+ const void* pNext
+ VkSubpassDescriptionFlags flags
+ VkPipelineBindPoint pipelineBindPoint
+ u32 viewMask
+ u32 inputAttachmentCount
+ const VkAttachmentReference2KHR* pInputAttachments
+ u32 colorAttachmentCount
+ const VkAttachmentReference2KHR* pColorAttachments
+ const VkAttachmentReference2KHR* pResolveAttachments
+ const VkAttachmentReference2KHR* pDepthStencilAttachment
+ u32 preserveAttachmentCount
+ const u32* pPreserveAttachments
+}
+
+@extension("VK_KHR_create_renderpass2") // 110
+class VkSubpassDependency2KHR {
+ VkStructureType sType
+ const void* pNext
+ u32 srcSubpass
+ u32 dstSubpass
+ VkPipelineStageFlags srcStageMask
+ VkPipelineStageFlags dstStageMask
+ VkAccessFlags srcAccessMask
+ VkAccessFlags dstAccessMask
+ VkDependencyFlags dependencyFlags
+ s32 viewOffset
+}
+
+@extension("VK_KHR_create_renderpass2") // 110
+class VkRenderPassCreateInfo2KHR {
+ VkStructureType sType
+ const void* pNext
+ VkRenderPassCreateFlags flags
+ u32 attachmentCount
+ const VkAttachmentDescription2KHR* pAttachments
+ u32 subpassCount
+ const VkSubpassDescription2KHR* pSubpasses
+ u32 dependencyCount
+ const VkSubpassDependency2KHR* pDependencies
+ u32 correlatedViewMaskCount
+ const u32* pCorrelatedViewMasks
+}
+
+@extension("VK_KHR_create_renderpass2") // 110
+class VkSubpassBeginInfoKHR {
+ VkStructureType sType
+ const void* pNext
+ VkSubpassContents contents
+}
+
+@extension("VK_KHR_create_renderpass2") // 110
+class VkSubpassEndInfoKHR {
+ VkStructureType sType
+ const void* pNext
+}
+
@extension("VK_KHR_shared_presentable_image") // 112
class VkSharedPresentSurfaceCapabilitiesKHR {
VkStructureType sType
@@ -6558,6 +6716,15 @@
VkQueueGlobalPriorityEXT globalPriority
}
+@extension("VK_KHR_8bit_storage") // 178
+class VkPhysicalDevice8BitStorageFeaturesKHR {
+ VkStructureType sType
+ void* pNext
+ VkBool32 storageBuffer8BitAccess
+ VkBool32 uniformAndStorageBuffer8BitAccess
+ VkBool32 storagePushConstant8
+}
+
@extension("VK_EXT_external_memory_host") // 179
class VkImportMemoryHostPointerInfoEXT {
VkStructureType sType
@@ -9799,6 +9966,17 @@
const VkWriteDescriptorSet* pDescriptorWrites) {
}
+@extension("VK_EXT_conditional_rendering") // 82
+cmd void vkCmdBeginConditionalRenderingEXT(
+ VkCommandBuffer commandBuffer,
+ const VkConditionalRenderingBeginInfoEXT* pConditionalRenderingBegin) {
+}
+
+@extension("VK_EXT_conditional_rendering") // 82
+cmd void vkCmdEndConditionalRenderingEXT(
+ VkCommandBuffer commandBuffer) {
+}
+
@extension("VK_KHR_descriptor_update_template") // 86
cmd VkResult vkCreateDescriptorUpdateTemplateKHR(
VkDevice device,
@@ -10018,6 +10196,35 @@
const VkHdrMetadataEXT* pMetadata) {
}
+@extension("VK_KHR_create_renderpass2") // 110
+cmd VkResult vkCreateRenderPass2KHR(
+ VkDevice device,
+ const VkRenderPassCreateInfo2KHR* pCreateInfo,
+ const VkAllocationCallbacks* pAllocator,
+ VkRenderPass* pRenderPass) {
+ return ?
+}
+
+@extension("VK_KHR_create_renderpass2") // 110
+cmd void vkCmdBeginRenderPass2KHR(
+ VkCommandBuffer commandBuffer,
+ const VkRenderPassBeginInfo* pRenderPassBegin,
+ const VkSubpassBeginInfoKHR* pSubpassBeginInfo) {
+}
+
+@extension("VK_KHR_create_renderpass2") // 110
+cmd void vkCmdNextSubpass2KHR(
+ VkCommandBuffer commandBuffer,
+ const VkSubpassBeginInfoKHR* pSubpassBeginInfo,
+ const VkSubpassEndInfoKHR* pSubpassEndInfo) {
+}
+
+@extension("VK_KHR_create_renderpass2") // 110
+cmd void vkCmdEndRenderPass2KHR(
+ VkCommandBuffer commandBuffer,
+ const VkSubpassEndInfoKHR* pSubpassEndInfo) {
+}
+
@extension("VK_KHR_shared_presentable_image") // 112
cmd VkResult vkGetSwapchainStatusKHR(
VkDevice device,
diff --git a/vulkan/include/vulkan/vulkan_core.h b/vulkan/include/vulkan/vulkan_core.h
index a28661f..06c8607 100644
--- a/vulkan/include/vulkan/vulkan_core.h
+++ b/vulkan/include/vulkan/vulkan_core.h
@@ -43,7 +43,7 @@
#define VK_VERSION_MINOR(version) (((uint32_t)(version) >> 12) & 0x3ff)
#define VK_VERSION_PATCH(version) ((uint32_t)(version) & 0xfff)
// Version of this file
-#define VK_HEADER_VERSION 76
+#define VK_HEADER_VERSION 80
#define VK_NULL_HANDLE 0
@@ -320,6 +320,9 @@
VK_STRUCTURE_TYPE_IMPORT_SEMAPHORE_FD_INFO_KHR = 1000079000,
VK_STRUCTURE_TYPE_SEMAPHORE_GET_FD_INFO_KHR = 1000079001,
VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PUSH_DESCRIPTOR_PROPERTIES_KHR = 1000080000,
+ VK_STRUCTURE_TYPE_COMMAND_BUFFER_INHERITANCE_CONDITIONAL_RENDERING_INFO_EXT = 1000081000,
+ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CONDITIONAL_RENDERING_FEATURES_EXT = 1000081001,
+ VK_STRUCTURE_TYPE_CONDITIONAL_RENDERING_BEGIN_INFO_EXT = 1000081002,
VK_STRUCTURE_TYPE_PRESENT_REGIONS_KHR = 1000084000,
VK_STRUCTURE_TYPE_OBJECT_TABLE_CREATE_INFO_NVX = 1000086000,
VK_STRUCTURE_TYPE_INDIRECT_COMMANDS_LAYOUT_CREATE_INFO_NVX = 1000086001,
@@ -341,6 +344,13 @@
VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CONSERVATIVE_RASTERIZATION_PROPERTIES_EXT = 1000101000,
VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_CONSERVATIVE_STATE_CREATE_INFO_EXT = 1000101001,
VK_STRUCTURE_TYPE_HDR_METADATA_EXT = 1000105000,
+ VK_STRUCTURE_TYPE_ATTACHMENT_DESCRIPTION_2_KHR = 1000109000,
+ VK_STRUCTURE_TYPE_ATTACHMENT_REFERENCE_2_KHR = 1000109001,
+ VK_STRUCTURE_TYPE_SUBPASS_DESCRIPTION_2_KHR = 1000109002,
+ VK_STRUCTURE_TYPE_SUBPASS_DEPENDENCY_2_KHR = 1000109003,
+ VK_STRUCTURE_TYPE_RENDER_PASS_CREATE_INFO_2_KHR = 1000109004,
+ VK_STRUCTURE_TYPE_SUBPASS_BEGIN_INFO_KHR = 1000109005,
+ VK_STRUCTURE_TYPE_SUBPASS_END_INFO_KHR = 1000109006,
VK_STRUCTURE_TYPE_SHARED_PRESENT_SURFACE_CAPABILITIES_KHR = 1000111000,
VK_STRUCTURE_TYPE_IMPORT_FENCE_WIN32_HANDLE_INFO_KHR = 1000114000,
VK_STRUCTURE_TYPE_EXPORT_FENCE_WIN32_HANDLE_INFO_KHR = 1000114001,
@@ -389,6 +399,7 @@
VK_STRUCTURE_TYPE_DESCRIPTOR_SET_VARIABLE_DESCRIPTOR_COUNT_ALLOCATE_INFO_EXT = 1000161003,
VK_STRUCTURE_TYPE_DESCRIPTOR_SET_VARIABLE_DESCRIPTOR_COUNT_LAYOUT_SUPPORT_EXT = 1000161004,
VK_STRUCTURE_TYPE_DEVICE_QUEUE_GLOBAL_PRIORITY_CREATE_INFO_EXT = 1000174000,
+ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_8BIT_STORAGE_FEATURES_KHR = 1000177000,
VK_STRUCTURE_TYPE_IMPORT_MEMORY_HOST_POINTER_INFO_EXT = 1000178000,
VK_STRUCTURE_TYPE_MEMORY_HOST_POINTER_PROPERTIES_EXT = 1000178001,
VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_MEMORY_HOST_PROPERTIES_EXT = 1000178002,
@@ -1214,6 +1225,16 @@
VK_OBJECT_TYPE_MAX_ENUM = 0x7FFFFFFF
} VkObjectType;
+typedef enum VkVendorId {
+ VK_VENDOR_ID_VIV = 0x10001,
+ VK_VENDOR_ID_VSI = 0x10002,
+ VK_VENDOR_ID_KAZAN = 0x10003,
+ VK_VENDOR_ID_BEGIN_RANGE = VK_VENDOR_ID_VIV,
+ VK_VENDOR_ID_END_RANGE = VK_VENDOR_ID_KAZAN,
+ VK_VENDOR_ID_RANGE_SIZE = (VK_VENDOR_ID_KAZAN - VK_VENDOR_ID_VIV + 1),
+ VK_VENDOR_ID_MAX_ENUM = 0x7FFFFFFF
+} VkVendorId;
+
typedef VkFlags VkInstanceCreateFlags;
typedef enum VkFormatFeatureFlagBits {
@@ -1357,6 +1378,7 @@
VK_PIPELINE_STAGE_HOST_BIT = 0x00004000,
VK_PIPELINE_STAGE_ALL_GRAPHICS_BIT = 0x00008000,
VK_PIPELINE_STAGE_ALL_COMMANDS_BIT = 0x00010000,
+ VK_PIPELINE_STAGE_CONDITIONAL_RENDERING_BIT_EXT = 0x00040000,
VK_PIPELINE_STAGE_COMMAND_PROCESS_BIT_NVX = 0x00020000,
VK_PIPELINE_STAGE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF
} VkPipelineStageFlagBits;
@@ -1445,6 +1467,7 @@
VK_BUFFER_USAGE_INDEX_BUFFER_BIT = 0x00000040,
VK_BUFFER_USAGE_VERTEX_BUFFER_BIT = 0x00000080,
VK_BUFFER_USAGE_INDIRECT_BUFFER_BIT = 0x00000100,
+ VK_BUFFER_USAGE_CONDITIONAL_RENDERING_BIT_EXT = 0x00000200,
VK_BUFFER_USAGE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF
} VkBufferUsageFlagBits;
typedef VkFlags VkBufferUsageFlags;
@@ -1556,6 +1579,7 @@
VK_ACCESS_HOST_WRITE_BIT = 0x00004000,
VK_ACCESS_MEMORY_READ_BIT = 0x00008000,
VK_ACCESS_MEMORY_WRITE_BIT = 0x00010000,
+ VK_ACCESS_CONDITIONAL_RENDERING_READ_BIT_EXT = 0x00100000,
VK_ACCESS_COMMAND_PROCESS_READ_BIT_NVX = 0x00020000,
VK_ACCESS_COMMAND_PROCESS_WRITE_BIT_NVX = 0x00040000,
VK_ACCESS_COLOR_ATTACHMENT_READ_NONCOHERENT_BIT_EXT = 0x00080000,
@@ -5425,6 +5449,114 @@
const void* pData);
#endif
+#define VK_KHR_create_renderpass2 1
+#define VK_KHR_CREATE_RENDERPASS_2_SPEC_VERSION 1
+#define VK_KHR_CREATE_RENDERPASS_2_EXTENSION_NAME "VK_KHR_create_renderpass2"
+
+typedef struct VkAttachmentDescription2KHR {
+ VkStructureType sType;
+ const void* pNext;
+ VkAttachmentDescriptionFlags flags;
+ VkFormat format;
+ VkSampleCountFlagBits samples;
+ VkAttachmentLoadOp loadOp;
+ VkAttachmentStoreOp storeOp;
+ VkAttachmentLoadOp stencilLoadOp;
+ VkAttachmentStoreOp stencilStoreOp;
+ VkImageLayout initialLayout;
+ VkImageLayout finalLayout;
+} VkAttachmentDescription2KHR;
+
+typedef struct VkAttachmentReference2KHR {
+ VkStructureType sType;
+ const void* pNext;
+ uint32_t attachment;
+ VkImageLayout layout;
+ VkImageAspectFlags aspectMask;
+} VkAttachmentReference2KHR;
+
+typedef struct VkSubpassDescription2KHR {
+ VkStructureType sType;
+ const void* pNext;
+ VkSubpassDescriptionFlags flags;
+ VkPipelineBindPoint pipelineBindPoint;
+ uint32_t viewMask;
+ uint32_t inputAttachmentCount;
+ const VkAttachmentReference2KHR* pInputAttachments;
+ uint32_t colorAttachmentCount;
+ const VkAttachmentReference2KHR* pColorAttachments;
+ const VkAttachmentReference2KHR* pResolveAttachments;
+ const VkAttachmentReference2KHR* pDepthStencilAttachment;
+ uint32_t preserveAttachmentCount;
+ const uint32_t* pPreserveAttachments;
+} VkSubpassDescription2KHR;
+
+typedef struct VkSubpassDependency2KHR {
+ VkStructureType sType;
+ const void* pNext;
+ uint32_t srcSubpass;
+ uint32_t dstSubpass;
+ VkPipelineStageFlags srcStageMask;
+ VkPipelineStageFlags dstStageMask;
+ VkAccessFlags srcAccessMask;
+ VkAccessFlags dstAccessMask;
+ VkDependencyFlags dependencyFlags;
+ int32_t viewOffset;
+} VkSubpassDependency2KHR;
+
+typedef struct VkRenderPassCreateInfo2KHR {
+ VkStructureType sType;
+ const void* pNext;
+ VkRenderPassCreateFlags flags;
+ uint32_t attachmentCount;
+ const VkAttachmentDescription2KHR* pAttachments;
+ uint32_t subpassCount;
+ const VkSubpassDescription2KHR* pSubpasses;
+ uint32_t dependencyCount;
+ const VkSubpassDependency2KHR* pDependencies;
+ uint32_t correlatedViewMaskCount;
+ const uint32_t* pCorrelatedViewMasks;
+} VkRenderPassCreateInfo2KHR;
+
+typedef struct VkSubpassBeginInfoKHR {
+ VkStructureType sType;
+ const void* pNext;
+ VkSubpassContents contents;
+} VkSubpassBeginInfoKHR;
+
+typedef struct VkSubpassEndInfoKHR {
+ VkStructureType sType;
+ const void* pNext;
+} VkSubpassEndInfoKHR;
+
+
+typedef VkResult (VKAPI_PTR *PFN_vkCreateRenderPass2KHR)(VkDevice device, const VkRenderPassCreateInfo2KHR* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkRenderPass* pRenderPass);
+typedef void (VKAPI_PTR *PFN_vkCmdBeginRenderPass2KHR)(VkCommandBuffer commandBuffer, const VkRenderPassBeginInfo* pRenderPassBegin, const VkSubpassBeginInfoKHR* pSubpassBeginInfo);
+typedef void (VKAPI_PTR *PFN_vkCmdNextSubpass2KHR)(VkCommandBuffer commandBuffer, const VkSubpassBeginInfoKHR* pSubpassBeginInfo, const VkSubpassEndInfoKHR* pSubpassEndInfo);
+typedef void (VKAPI_PTR *PFN_vkCmdEndRenderPass2KHR)(VkCommandBuffer commandBuffer, const VkSubpassEndInfoKHR* pSubpassEndInfo);
+
+#ifndef VK_NO_PROTOTYPES
+VKAPI_ATTR VkResult VKAPI_CALL vkCreateRenderPass2KHR(
+ VkDevice device,
+ const VkRenderPassCreateInfo2KHR* pCreateInfo,
+ const VkAllocationCallbacks* pAllocator,
+ VkRenderPass* pRenderPass);
+
+VKAPI_ATTR void VKAPI_CALL vkCmdBeginRenderPass2KHR(
+ VkCommandBuffer commandBuffer,
+ const VkRenderPassBeginInfo* pRenderPassBegin,
+ const VkSubpassBeginInfoKHR* pSubpassBeginInfo);
+
+VKAPI_ATTR void VKAPI_CALL vkCmdNextSubpass2KHR(
+ VkCommandBuffer commandBuffer,
+ const VkSubpassBeginInfoKHR* pSubpassBeginInfo,
+ const VkSubpassEndInfoKHR* pSubpassEndInfo);
+
+VKAPI_ATTR void VKAPI_CALL vkCmdEndRenderPass2KHR(
+ VkCommandBuffer commandBuffer,
+ const VkSubpassEndInfoKHR* pSubpassEndInfo);
+#endif
+
#define VK_KHR_shared_presentable_image 1
#define VK_KHR_SHARED_PRESENTABLE_IMAGE_SPEC_VERSION 1
#define VK_KHR_SHARED_PRESENTABLE_IMAGE_EXTENSION_NAME "VK_KHR_shared_presentable_image"
@@ -5833,6 +5965,20 @@
uint32_t stride);
#endif
+#define VK_KHR_8bit_storage 1
+#define VK_KHR_8BIT_STORAGE_SPEC_VERSION 1
+#define VK_KHR_8BIT_STORAGE_EXTENSION_NAME "VK_KHR_8bit_storage"
+
+typedef struct VkPhysicalDevice8BitStorageFeaturesKHR {
+ VkStructureType sType;
+ void* pNext;
+ VkBool32 storageBuffer8BitAccess;
+ VkBool32 uniformAndStorageBuffer8BitAccess;
+ VkBool32 storagePushConstant8;
+} VkPhysicalDevice8BitStorageFeaturesKHR;
+
+
+
#define VK_EXT_debug_report 1
VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkDebugReportCallbackEXT)
@@ -6283,6 +6429,51 @@
#define VK_EXT_SHADER_SUBGROUP_VOTE_EXTENSION_NAME "VK_EXT_shader_subgroup_vote"
+#define VK_EXT_conditional_rendering 1
+#define VK_EXT_CONDITIONAL_RENDERING_SPEC_VERSION 1
+#define VK_EXT_CONDITIONAL_RENDERING_EXTENSION_NAME "VK_EXT_conditional_rendering"
+
+
+typedef enum VkConditionalRenderingFlagBitsEXT {
+ VK_CONDITIONAL_RENDERING_INVERTED_BIT_EXT = 0x00000001,
+ VK_CONDITIONAL_RENDERING_FLAG_BITS_MAX_ENUM_EXT = 0x7FFFFFFF
+} VkConditionalRenderingFlagBitsEXT;
+typedef VkFlags VkConditionalRenderingFlagsEXT;
+
+typedef struct VkConditionalRenderingBeginInfoEXT {
+ VkStructureType sType;
+ const void* pNext;
+ VkBuffer buffer;
+ VkDeviceSize offset;
+ VkConditionalRenderingFlagsEXT flags;
+} VkConditionalRenderingBeginInfoEXT;
+
+typedef struct VkPhysicalDeviceConditionalRenderingFeaturesEXT {
+ VkStructureType sType;
+ void* pNext;
+ VkBool32 conditionalRendering;
+ VkBool32 inheritedConditionalRendering;
+} VkPhysicalDeviceConditionalRenderingFeaturesEXT;
+
+typedef struct VkCommandBufferInheritanceConditionalRenderingInfoEXT {
+ VkStructureType sType;
+ const void* pNext;
+ VkBool32 conditionalRenderingEnable;
+} VkCommandBufferInheritanceConditionalRenderingInfoEXT;
+
+
+typedef void (VKAPI_PTR *PFN_vkCmdBeginConditionalRenderingEXT)(VkCommandBuffer commandBuffer, const VkConditionalRenderingBeginInfoEXT* pConditionalRenderingBegin);
+typedef void (VKAPI_PTR *PFN_vkCmdEndConditionalRenderingEXT)(VkCommandBuffer commandBuffer);
+
+#ifndef VK_NO_PROTOTYPES
+VKAPI_ATTR void VKAPI_CALL vkCmdBeginConditionalRenderingEXT(
+ VkCommandBuffer commandBuffer,
+ const VkConditionalRenderingBeginInfoEXT* pConditionalRenderingBegin);
+
+VKAPI_ATTR void VKAPI_CALL vkCmdEndConditionalRenderingEXT(
+ VkCommandBuffer commandBuffer);
+#endif
+
#define VK_NVX_device_generated_commands 1
VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkObjectTableNVX)
VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkIndirectCommandsLayoutNVX)
diff --git a/vulkan/nulldrv/Android.bp b/vulkan/nulldrv/Android.bp
index 3329609..7be9c66 100644
--- a/vulkan/nulldrv/Android.bp
+++ b/vulkan/nulldrv/Android.bp
@@ -32,7 +32,6 @@
"-DLOG_NDEBUG=0",
],
cppflags: [
- "-std=c++1y",
"-Wno-c++98-compat-pedantic",
"-Wno-c99-extensions",
],
diff --git a/vulkan/tools/Android.bp b/vulkan/tools/Android.bp
index d81d9ec..2514094 100644
--- a/vulkan/tools/Android.bp
+++ b/vulkan/tools/Android.bp
@@ -29,7 +29,6 @@
"-Wno-switch-enum",
],
cppflags: [
- "-std=c++1y",
"-Wno-c++98-compat-pedantic",
"-Wno-c99-extensions",
"-Wno-old-style-cast",