Android/frameworks_base
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Merge changes from topic "bound status" into rvc-dev am: a721ccdc7c am: a10bf2e92c

Browse Source 
Change-Id: I443bb9e56a4cba7dbb3e73488d5f5b1b8c241db6
This commit is contained in:
TreeHugger Robot
2020-04-23 23:12:40 +00:00
committed by Automerger Merge Worker
parent 0cd348cf06 a10bf2e92c
commit 4ed82d2559
12 changed files with 219 additions and 253 deletions
Download Patch File Download Diff File Expand all files Collapse all files

14
core/java/android/content/pm/DataLoaderManager.java
View File

@@ -41,17 +41,16 @@ public class DataLoaderManager {
* @param dataLoaderId ID for the new data loader binder service.
* @param params DataLoaderParamsParcel object that contains data loader params, including
* its package name, class name, and additional parameters.
* @param control FileSystemControlParcel that contains filesystem control handlers.
* @param listener Callback for the data loader service to report status back to the
* caller.
* @return false if 1) target ID collides with a data loader that is already bound to data
* loader manager; 2) package name is not specified; 3) fails to find data loader package;
* or 4) fails to bind to the specified data loader service, otherwise return true.
*/
public boolean initializeDataLoader(int dataLoaderId, @NonNull DataLoaderParamsParcel params,
@NonNull FileSystemControlParcel control, @NonNull IDataLoaderStatusListener listener) {
public boolean bindToDataLoader(int dataLoaderId, @NonNull DataLoaderParamsParcel params,
@NonNull IDataLoaderStatusListener listener) {
try {
return mService.initializeDataLoader(dataLoaderId, params, control, listener);
return mService.bindToDataLoader(dataLoaderId, params, listener);
} catch (RemoteException e) {
throw e.rethrowFromSystemServer();
}
@@ -70,12 +69,13 @@ public class DataLoaderManager {
}
/**
* Destroys the data loader binder service and removes it from data loader manager service.
* Unbinds from a data loader binder service, specified by its ID.
* DataLoader will receive destroy notification.
*/
@Nullable
public void destroyDataLoader(int dataLoaderId) {
public void unbindFromDataLoader(int dataLoaderId) {
try {
mService.destroyDataLoader(dataLoaderId);
mService.unbindFromDataLoader(dataLoaderId);
} catch (RemoteException e) {
throw e.rethrowFromSystemServer();
}

8
core/java/android/content/pm/IDataLoaderManager.aidl
View File

@@ -23,8 +23,8 @@ import android.content.pm.IDataLoaderStatusListener;
/** @hide */
interface IDataLoaderManager {
boolean initializeDataLoader(int id, in DataLoaderParamsParcel params,
in FileSystemControlParcel control, IDataLoaderStatusListener listener);
boolean bindToDataLoader(int id, in DataLoaderParamsParcel params,
IDataLoaderStatusListener listener);
IDataLoader getDataLoader(int dataLoaderId);
void destroyDataLoader(int dataLoaderId);
}
void unbindFromDataLoader(int dataLoaderId);
}

22
core/java/android/content/pm/IDataLoaderStatusListener.aidl
View File

@@ -21,30 +21,30 @@ package android.content.pm;
* @hide
*/
oneway interface IDataLoaderStatusListener {
/** When this status is returned from DataLoader, it means that the DataLoader
* process is running, bound to and has handled onCreate(). */
const int DATA_LOADER_CREATED = 0;
/** Listener will receive this status when the DataLoader process died,
* binder disconnected or class destroyed. */
const int DATA_LOADER_DESTROYED = 1;
/** The DataLoader process died, binder disconnected or class destroyed. */
const int DATA_LOADER_DESTROYED = 0;
/** DataLoader process is running and bound to. */
const int DATA_LOADER_BOUND = 1;
/** DataLoader has handled onCreate(). */
const int DATA_LOADER_CREATED = 2;
/** DataLoader can receive missing pages and read pages notifications,
* and ready to provide data. */
const int DATA_LOADER_STARTED = 2;
const int DATA_LOADER_STARTED = 3;
/** DataLoader no longer ready to provide data and is not receiving
* any notifications from IncFS. */
const int DATA_LOADER_STOPPED = 3;
const int DATA_LOADER_STOPPED = 4;
/** DataLoader streamed everything necessary to continue installation. */
const int DATA_LOADER_IMAGE_READY = 4;
const int DATA_LOADER_IMAGE_READY = 5;
/** Installation can't continue as DataLoader failed to stream necessary data. */
const int DATA_LOADER_IMAGE_NOT_READY = 5;
const int DATA_LOADER_IMAGE_NOT_READY = 6;
/** DataLoader reports that this instance is invalid and can never be restored.
* Warning: this is a terminal status that data loader should use carefully and
* the system should almost never use - e.g. only if all recovery attempts
* fail and all retry limits are exceeded. */
const int DATA_LOADER_UNRECOVERABLE = 6;
const int DATA_LOADER_UNRECOVERABLE = 7;
/** Data loader status callback */
void onStatusChanged(in int dataLoaderId, in int status);

137
services/core/java/com/android/server/pm/DataLoaderManagerService.java
View File

@@ -23,7 +23,6 @@ import android.content.Intent;
import android.content.ServiceConnection;
import android.content.pm.ApplicationInfo;
import android.content.pm.DataLoaderParamsParcel;
import android.content.pm.FileSystemControlParcel;
import android.content.pm.IDataLoader;
import android.content.pm.IDataLoaderManager;
import android.content.pm.IDataLoaderStatusListener;
@@ -35,11 +34,8 @@ import android.os.UserHandle;
import android.util.Slog;
import android.util.SparseArray;
import com.android.internal.annotations.GuardedBy;
import com.android.server.SystemService;
import libcore.io.IoUtils;
import java.util.List;
/**
@@ -51,8 +47,6 @@ public class DataLoaderManagerService extends SystemService {
private static final String TAG = "DataLoaderManager";
private final Context mContext;
private final DataLoaderManagerBinderService mBinderService;
private final Object mLock = new Object();
@GuardedBy("mLock")
private SparseArray<DataLoaderServiceConnection> mServiceConnections = new SparseArray<>();
public DataLoaderManagerService(Context context) {
@@ -66,53 +60,35 @@ public class DataLoaderManagerService extends SystemService {
publishBinderService(Context.DATA_LOADER_MANAGER_SERVICE, mBinderService);
}
private static void closeQuietly(FileSystemControlParcel control) {
if (control == null || control.incremental == null) {
return;
}
IoUtils.closeQuietly(control.incremental.cmd);
IoUtils.closeQuietly(control.incremental.pendingReads);
IoUtils.closeQuietly(control.incremental.log);
}
final class DataLoaderManagerBinderService extends IDataLoaderManager.Stub {
@Override
public boolean initializeDataLoader(int dataLoaderId, DataLoaderParamsParcel params,
FileSystemControlParcel control, IDataLoaderStatusListener listener) {
DataLoaderServiceConnection connection = null;
try {
synchronized (mLock) {
if (mServiceConnections.get(dataLoaderId) != null) {
Slog.e(TAG, "Data loader of ID=" + dataLoaderId + " already exists.");
return false;
}
}
ComponentName componentName =
new ComponentName(params.packageName, params.className);
ComponentName dataLoaderComponent = resolveDataLoaderComponentName(componentName);
if (dataLoaderComponent == null) {
return false;
}
// Binds to the specific data loader service
connection =
new DataLoaderServiceConnection(dataLoaderId, params,
control, listener);
control = null; // now connection manages it
Intent intent = new Intent();
intent.setComponent(dataLoaderComponent);
if (!mContext.bindServiceAsUser(intent, connection, Context.BIND_AUTO_CREATE,
UserHandle.of(UserHandle.getCallingUserId()))) {
Slog.e(TAG, "Failed to bind to data loader binder service.");
mContext.unbindService(connection);
return false;
}
connection = null;
} finally {
DataLoaderManagerService.closeQuietly(control);
if (connection != null) {
connection.close();
public boolean bindToDataLoader(int dataLoaderId, DataLoaderParamsParcel params,
IDataLoaderStatusListener listener) {
synchronized (mServiceConnections) {
if (mServiceConnections.get(dataLoaderId) != null) {
return true;
}
}
ComponentName componentName = new ComponentName(params.packageName, params.className);
ComponentName dataLoaderComponent = resolveDataLoaderComponentName(componentName);
if (dataLoaderComponent == null) {
Slog.e(TAG, "Invalid component: " + componentName + " for ID=" + dataLoaderId);
return false;
}
// Binds to the specific data loader service.
DataLoaderServiceConnection connection = new DataLoaderServiceConnection(dataLoaderId,
listener);
Intent intent = new Intent();
intent.setComponent(dataLoaderComponent);
if (!mContext.bindServiceAsUser(intent, connection, Context.BIND_AUTO_CREATE,
UserHandle.of(UserHandle.getCallingUserId()))) {
Slog.e(TAG,
"Failed to bind to: " + dataLoaderComponent + " for ID=" + dataLoaderId);
mContext.unbindService(connection);
return false;
}
return true;
}
@@ -169,7 +145,7 @@ public class DataLoaderManagerService extends SystemService {
*/
@Override
public @Nullable IDataLoader getDataLoader(int dataLoaderId) {
synchronized (mLock) {
synchronized (mServiceConnections) {
DataLoaderServiceConnection serviceConnection = mServiceConnections.get(
dataLoaderId, null);
if (serviceConnection == null) {
@@ -180,14 +156,14 @@ public class DataLoaderManagerService extends SystemService {
}
/**
* Destroys a data loader binder service, specified by its ID.
* Unbinds from a data loader binder service, specified by its ID. DataLoader will receive
* destroy notification.
*/
@Override
public void destroyDataLoader(int dataLoaderId) {
synchronized (mLock) {
public void unbindFromDataLoader(int dataLoaderId) {
synchronized (mServiceConnections) {
DataLoaderServiceConnection serviceConnection = mServiceConnections.get(
dataLoaderId, null);
if (serviceConnection == null) {
return;
}
@@ -196,18 +172,13 @@ public class DataLoaderManagerService extends SystemService {
}
}
class DataLoaderServiceConnection implements ServiceConnection, AutoCloseable {
private class DataLoaderServiceConnection implements ServiceConnection {
final int mId;
final DataLoaderParamsParcel mParams;
final FileSystemControlParcel mControl;
final IDataLoaderStatusListener mListener;
IDataLoader mDataLoader;
DataLoaderServiceConnection(int id, DataLoaderParamsParcel params,
FileSystemControlParcel control, IDataLoaderStatusListener listener) {
DataLoaderServiceConnection(int id, IDataLoaderStatusListener listener) {
mId = id;
mParams = params;
mControl = control;
mListener = listener;
mDataLoader = null;
}
@@ -215,44 +186,40 @@ public class DataLoaderManagerService extends SystemService {
@Override
public void onServiceConnected(ComponentName className, IBinder service) {
mDataLoader = IDataLoader.Stub.asInterface(service);
synchronized (mLock) {
if (mDataLoader == null) {
onNullBinding(className);
return;
}
synchronized (mServiceConnections) {
if (mServiceConnections.get(mId) != null) {
// Another connection already bound for this ID.
mContext.unbindService(this);
return;
}
mServiceConnections.append(mId, this);
}
try {
mDataLoader.create(mId, mParams, mControl, mListener);
} catch (RemoteException e) {
Slog.e(TAG, "Failed to create data loader service.", e);
}
callListener(IDataLoaderStatusListener.DATA_LOADER_BOUND);
}
@Override
public void onServiceDisconnected(ComponentName arg0) {
Slog.i(TAG, "DataLoader " + mId + " disconnected, but will try to recover");
callListener(IDataLoaderStatusListener.DATA_LOADER_DESTROYED);
remove();
destroy();
}
@Override
public void onBindingDied(ComponentName name) {
Slog.i(TAG, "DataLoader " + mId + " died");
callListener(IDataLoaderStatusListener.DATA_LOADER_DESTROYED);
mContext.unbindService(this);
close();
remove();
destroy();
}
@Override
public void onNullBinding(ComponentName name) {
Slog.i(TAG, "DataLoader " + mId + " failed to start");
callListener(IDataLoaderStatusListener.DATA_LOADER_DESTROYED);
mContext.unbindService(this);
close();
remove();
}
@Override
public void close() {
DataLoaderManagerService.closeQuietly(mControl);
destroy();
}
IDataLoader getDataLoader() {
@@ -260,17 +227,19 @@ public class DataLoaderManagerService extends SystemService {
}
void destroy() {
try {
mDataLoader.destroy(mId);
} catch (RemoteException ignored) {
if (mDataLoader != null) {
try {
mDataLoader.destroy(mId);
} catch (RemoteException ignored) {
}
mDataLoader = null;
}
mContext.unbindService(this);
close();
remove();
}
private void remove() {
synchronized (mLock) {
synchronized (mServiceConnections) {
mServiceConnections.remove(mId);
}
}

25
services/core/java/com/android/server/pm/PackageInstallerSession.java
View File

@@ -2601,8 +2601,9 @@ public class PackageInstallerSession extends IPackageInstallerSession.Stub {
"Failed to find data loader manager service");
}
final DataLoaderParams params = this.params.dataLoaderParams;
final boolean manualStartAndDestroy = !isIncrementalInstallation();
IDataLoaderStatusListener listener = new IDataLoaderStatusListener.Stub() {
final IDataLoaderStatusListener listener = new IDataLoaderStatusListener.Stub() {
@Override
public void onStatusChanged(int dataLoaderId, int status) {
switch (status) {
@@ -2629,6 +2630,15 @@ public class PackageInstallerSession extends IPackageInstallerSession.Stub {
}
switch (status) {
case IDataLoaderStatusListener.DATA_LOADER_BOUND: {
if (manualStartAndDestroy) {
FileSystemControlParcel control = new FileSystemControlParcel();
control.callback = new FileSystemConnector(addedFiles);
dataLoader.create(dataLoaderId, params.getData(), control, this);
}
break;
}
case IDataLoaderStatusListener.DATA_LOADER_CREATED: {
if (manualStartAndDestroy) {
// IncrementalFileStorages will call start after all files are
@@ -2680,8 +2690,8 @@ public class PackageInstallerSession extends IPackageInstallerSession.Stub {
if (!manualStartAndDestroy) {
try {
mIncrementalFileStorages = IncrementalFileStorages.initialize(mContext,
stageDir, params.dataLoaderParams, listener, addedFiles);
mIncrementalFileStorages = IncrementalFileStorages.initialize(mContext, stageDir,
params, listener, addedFiles);
return false;
} catch (IOException e) {
throw new PackageManagerException(INSTALL_FAILED_MEDIA_UNAVAILABLE, e.getMessage(),
@@ -2689,13 +2699,8 @@ public class PackageInstallerSession extends IPackageInstallerSession.Stub {
}
}
final FileSystemConnector connector = new FileSystemConnector(addedFiles);
final FileSystemControlParcel control = new FileSystemControlParcel();
control.callback = connector;
final DataLoaderParams params = this.params.dataLoaderParams;
if (!dataLoaderManager.initializeDataLoader(
sessionId, params.getData(), control, listener)) {
if (!dataLoaderManager.bindToDataLoader(
sessionId, params.getData(), listener)) {
throw new PackageManagerException(INSTALL_FAILED_MEDIA_UNAVAILABLE,
"Failed to initialize data loader");
}

14
services/core/java/com/android/server/pm/PackageManagerShellCommandDataLoader.java
View File

@@ -217,7 +217,7 @@ public class PackageManagerShellCommandDataLoader extends DataLoaderService {
case Metadata.LOCAL_FILE: {
ParcelFileDescriptor incomingFd = null;
try {
incomingFd = getLocalFile(shellCommand, metadata.getData());
incomingFd = getLocalFilePFD(shellCommand, metadata.getData());
mConnector.writeData(file.getName(), 0, incomingFd.getStatSize(),
incomingFd);
} finally {
@@ -263,10 +263,20 @@ public class PackageManagerShellCommandDataLoader extends DataLoaderService {
}
}
static ParcelFileDescriptor getLocalFile(ShellCommand shellCommand, String filePath) {
static ParcelFileDescriptor getLocalFilePFD(ShellCommand shellCommand, String filePath) {
return shellCommand.openFileForSystem(filePath, "r");
}
static int getStdIn(ShellCommand shellCommand) {
ParcelFileDescriptor pfd = getStdInPFD(shellCommand);
return pfd == null ? -1 : pfd.detachFd();
}
static int getLocalFile(ShellCommand shellCommand, String filePath) {
ParcelFileDescriptor pfd = getLocalFilePFD(shellCommand, filePath);
return pfd == null ? -1 : pfd.detachFd();
}
@Override
public DataLoaderService.DataLoader onCreateDataLoader(
@NonNull DataLoaderParams dataLoaderParams) {

63
services/core/jni/com_android_server_pm_PackageManagerShellCommandDataLoader.cpp
View File

@@ -69,14 +69,9 @@ static constexpr auto PollTimeoutMs = 5000;
struct JniIds {
jclass packageManagerShellCommandDataLoader;
jmethodID pmscdLookupShellCommand;
jmethodID pmscdGetStdInPFD;
jmethodID pmscdGetStdIn;
jmethodID pmscdGetLocalFile;
jmethodID parcelFileDescriptorGetFileDescriptor;
jclass ioUtils;
jmethodID ioUtilsCloseQuietly;
JniIds(JNIEnv* env) {
packageManagerShellCommandDataLoader = (jclass)env->NewGlobalRef(
FindClassOrDie(env, "com/android/server/pm/PackageManagerShellCommandDataLoader"));
@@ -84,23 +79,11 @@ struct JniIds {
GetStaticMethodIDOrDie(env, packageManagerShellCommandDataLoader,
"lookupShellCommand",
"(Ljava/lang/String;)Landroid/os/ShellCommand;");
pmscdGetStdInPFD =
GetStaticMethodIDOrDie(env, packageManagerShellCommandDataLoader, "getStdInPFD",
"(Landroid/os/ShellCommand;)Landroid/os/"
"ParcelFileDescriptor;");
pmscdGetStdIn = GetStaticMethodIDOrDie(env, packageManagerShellCommandDataLoader,
"getStdIn", "(Landroid/os/ShellCommand;)I");
pmscdGetLocalFile =
GetStaticMethodIDOrDie(env, packageManagerShellCommandDataLoader, "getLocalFile",
"(Landroid/os/ShellCommand;Ljava/lang/String;)Landroid/os/"
"ParcelFileDescriptor;");
auto parcelFileDescriptor = FindClassOrDie(env, "android/os/ParcelFileDescriptor");
parcelFileDescriptorGetFileDescriptor =
GetMethodIDOrDie(env, parcelFileDescriptor, "getFileDescriptor",
"()Ljava/io/FileDescriptor;");
ioUtils = (jclass)env->NewGlobalRef(FindClassOrDie(env, "libcore/io/IoUtils"));
ioUtilsCloseQuietly = GetStaticMethodIDOrDie(env, ioUtils, "closeQuietly",
"(Ljava/lang/AutoCloseable;)V");
"(Landroid/os/ShellCommand;Ljava/lang/String;)I");
}
};
@@ -211,22 +194,6 @@ static inline IncFsSize verityTreeSizeForFile(IncFsSize fileSize) {
return total_tree_block_count * INCFS_DATA_FILE_BLOCK_SIZE;
}
static inline unique_fd convertPfdToFdAndDup(JNIEnv* env, const JniIds& jni, jobject pfd) {
if (!pfd) {
ALOGE("Missing In ParcelFileDescriptor.");
return {};
}
auto managedFd = env->CallObjectMethod(pfd, jni.parcelFileDescriptorGetFileDescriptor);
if (!pfd) {
ALOGE("Missing In FileDescriptor.");
return {};
}
unique_fd result{dup(jniGetFDFromFileDescriptor(env, managedFd))};
// Can be closed after dup.
env->CallStaticVoidMethod(jni.ioUtils, jni.ioUtilsCloseQuietly, pfd);
return result;
}
enum MetadataMode : int8_t {
STDIN = 0,
LOCAL_FILE = 1,
@@ -263,11 +230,9 @@ static inline InputDescs openLocalFile(JNIEnv* env, const JniIds& jni, jobject s
const std::string idsigPath = filePath + ".idsig";
auto idsigFd = convertPfdToFdAndDup(
env, jni,
env->CallStaticObjectMethod(jni.packageManagerShellCommandDataLoader,
jni.pmscdGetLocalFile, shellCommand,
env->NewStringUTF(idsigPath.c_str())));
unique_fd idsigFd{env->CallStaticIntMethod(jni.packageManagerShellCommandDataLoader,
jni.pmscdGetLocalFile, shellCommand,
env->NewStringUTF(idsigPath.c_str()))};
if (idsigFd.ok()) {
auto treeSize = verityTreeSizeForFile(size);
auto actualTreeSize = skipIdSigHeaders(idsigFd);
@@ -283,11 +248,9 @@ static inline InputDescs openLocalFile(JNIEnv* env, const JniIds& jni, jobject s
});
}
auto fileFd = convertPfdToFdAndDup(
env, jni,
env->CallStaticObjectMethod(jni.packageManagerShellCommandDataLoader,
jni.pmscdGetLocalFile, shellCommand,
env->NewStringUTF(filePath.c_str())));
unique_fd fileFd{env->CallStaticIntMethod(jni.packageManagerShellCommandDataLoader,
jni.pmscdGetLocalFile, shellCommand,
env->NewStringUTF(filePath.c_str()))};
if (fileFd.ok()) {
result.push_back(InputDesc{
.fd = std::move(fileFd),
@@ -307,10 +270,8 @@ static inline InputDescs openInputs(JNIEnv* env, const JniIds& jni, jobject shel
std::string(metadata.data, metadata.size));
}
auto fd = convertPfdToFdAndDup(
env, jni,
env->CallStaticObjectMethod(jni.packageManagerShellCommandDataLoader,
jni.pmscdGetStdInPFD, shellCommand));
unique_fd fd{env->CallStaticIntMethod(jni.packageManagerShellCommandDataLoader,
jni.pmscdGetStdIn, shellCommand)};
if (!fd.ok()) {
return {};
}

32
services/incremental/IncrementalService.cpp
View File

@@ -1709,12 +1709,30 @@ bool IncrementalService::DataLoaderStub::waitForStatus(int status, Clock::durati
[this, status] { return mCurrentStatus == status; });
}
bool IncrementalService::DataLoaderStub::bind() {
bool result = false;
auto status = mService.mDataLoaderManager->bindToDataLoader(mId, mParams, this, &result);
if (!status.isOk() || !result) {
LOG(ERROR) << "Failed to bind a data loader for mount " << mId;
return false;
}
return true;
}
bool IncrementalService::DataLoaderStub::create() {
bool created = false;
auto status = mService.mDataLoaderManager->initializeDataLoader(mId, mParams, mControl, this,
&created);
if (!status.isOk() || !created) {
LOG(ERROR) << "Failed to create a data loader for mount " << mId;
sp<IDataLoader> dataloader;
auto status = mService.mDataLoaderManager->getDataLoader(mId, &dataloader);
if (!status.isOk()) {
LOG(ERROR) << "Failed to get dataloader: " << status.toString8();
return false;
}
if (!dataloader) {
LOG(ERROR) << "DataLoader is null: " << status.toString8();
return false;
}
status = dataloader->create(mId, mParams, mControl, this);
if (!status.isOk()) {
LOG(ERROR) << "Failed to start DataLoader: " << status.toString8();
return false;
}
return true;
@@ -1740,7 +1758,7 @@ bool IncrementalService::DataLoaderStub::start() {
}
bool IncrementalService::DataLoaderStub::destroy() {
mService.mDataLoaderManager->destroyDataLoader(mId);
mService.mDataLoaderManager->unbindFromDataLoader(mId);
return true;
}
@@ -1776,6 +1794,8 @@ bool IncrementalService::DataLoaderStub::fsmStep() {
case IDataLoaderStatusListener::DATA_LOADER_CREATED:
switch (currentStatus) {
case IDataLoaderStatusListener::DATA_LOADER_DESTROYED:
return bind();
case IDataLoaderStatusListener::DATA_LOADER_BOUND:
return create();
}
break;

1
services/incremental/IncrementalService.h
View File

@@ -180,6 +180,7 @@ private:
bool isValid() const { return mId != kInvalidStorageId; }
bool bind();
bool create();
bool start();
bool destroy();

15
services/incremental/ServiceWrappers.cpp
View File

@@ -65,19 +65,18 @@ public:
RealDataLoaderManager(sp<content::pm::IDataLoaderManager> manager)
: mInterface(std::move(manager)) {}
~RealDataLoaderManager() = default;
binder::Status initializeDataLoader(MountId mountId,
const content::pm::DataLoaderParamsParcel& params,
const content::pm::FileSystemControlParcel& control,
const sp<content::pm::IDataLoaderStatusListener>& listener,
bool* _aidl_return) const final {
return mInterface->initializeDataLoader(mountId, params, control, listener, _aidl_return);
binder::Status bindToDataLoader(MountId mountId,
const content::pm::DataLoaderParamsParcel& params,
const sp<content::pm::IDataLoaderStatusListener>& listener,
bool* _aidl_return) const final {
return mInterface->bindToDataLoader(mountId, params, listener, _aidl_return);
}
binder::Status getDataLoader(MountId mountId,
sp<content::pm::IDataLoader>* _aidl_return) const final {
return mInterface->getDataLoader(mountId, _aidl_return);
}
binder::Status destroyDataLoader(MountId mountId) const final {
return mInterface->destroyDataLoader(mountId);
binder::Status unbindFromDataLoader(MountId mountId) const final {
return mInterface->unbindFromDataLoader(mountId);
}
private:

5
services/incremental/ServiceWrappers.h
View File

@@ -55,13 +55,12 @@ public:
class DataLoaderManagerWrapper {
public:
virtual ~DataLoaderManagerWrapper() = default;
virtual binder::Status initializeDataLoader(
virtual binder::Status bindToDataLoader(
MountId mountId, const content::pm::DataLoaderParamsParcel& params,
const content::pm::FileSystemControlParcel& control,
const sp<content::pm::IDataLoaderStatusListener>& listener, bool* result) const = 0;
virtual binder::Status getDataLoader(MountId mountId,
sp<content::pm::IDataLoader>* result) const = 0;
virtual binder::Status destroyDataLoader(MountId mountId) const = 0;
virtual binder::Status unbindFromDataLoader(MountId mountId) const = 0;
};
class IncFsWrapper {

136
services/incremental/test/IncrementalServiceTest.cpp
View File

@@ -131,18 +131,19 @@ public:
.WillByDefault(Invoke(this, &MockDataLoader::createOkNoStatus));
}
binder::Status createOk(int32_t id, const content::pm::DataLoaderParamsParcel&,
const content::pm::FileSystemControlParcel&,
binder::Status createOk(int32_t id, const content::pm::DataLoaderParamsParcel& params,
const content::pm::FileSystemControlParcel& control,
const sp<content::pm::IDataLoaderStatusListener>& listener) {
mListener = listener;
createOkNoStatus(id, params, control, listener);
if (mListener) {
mListener->onStatusChanged(id, IDataLoaderStatusListener::DATA_LOADER_CREATED);
}
return binder::Status::ok();
}
binder::Status createOkNoStatus(int32_t id, const content::pm::DataLoaderParamsParcel&,
const content::pm::FileSystemControlParcel&,
binder::Status createOkNoStatus(int32_t id, const content::pm::DataLoaderParamsParcel& params,
const content::pm::FileSystemControlParcel& control,
const sp<content::pm::IDataLoaderStatusListener>& listener) {
mServiceConnector = control.service;
mListener = listener;
return binder::Status::ok();
}
@@ -173,8 +174,15 @@ public:
}
return binder::Status::ok();
}
int32_t setStorageParams(bool enableReadLogs) {
int32_t result = -1;
EXPECT_NE(mServiceConnector.get(), nullptr);
EXPECT_TRUE(mServiceConnector->setStorageParams(enableReadLogs, &result).isOk());
return result;
}
private:
sp<IIncrementalServiceConnector> mServiceConnector;
sp<IDataLoaderStatusListener> mListener;
};
@@ -184,21 +192,20 @@ public:
EXPECT_TRUE(mDataLoaderHolder != nullptr);
}
MOCK_CONST_METHOD5(initializeDataLoader,
MOCK_CONST_METHOD4(bindToDataLoader,
binder::Status(int32_t mountId, const DataLoaderParamsParcel& params,
const FileSystemControlParcel& control,
const sp<IDataLoaderStatusListener>& listener,
bool* _aidl_return));
MOCK_CONST_METHOD2(getDataLoader,
binder::Status(int32_t mountId, sp<IDataLoader>* _aidl_return));
MOCK_CONST_METHOD1(destroyDataLoader, binder::Status(int32_t mountId));
MOCK_CONST_METHOD1(unbindFromDataLoader, binder::Status(int32_t mountId));
void initializeDataLoaderSuccess() {
ON_CALL(*this, initializeDataLoader(_, _, _, _, _))
.WillByDefault(Invoke(this, &MockDataLoaderManager::initializeDataLoaderOk));
void bindToDataLoaderSuccess() {
ON_CALL(*this, bindToDataLoader(_, _, _, _))
.WillByDefault(Invoke(this, &MockDataLoaderManager::bindToDataLoaderOk));
}
void initializeDataLoaderFails() {
ON_CALL(*this, initializeDataLoader(_, _, _, _, _))
void bindToDataLoaderFails() {
ON_CALL(*this, bindToDataLoader(_, _, _, _))
.WillByDefault(Return(
(binder::Status::fromExceptionCode(1, String8("failed to prepare")))));
}
@@ -206,20 +213,21 @@ public:
ON_CALL(*this, getDataLoader(_, _))
.WillByDefault(Invoke(this, &MockDataLoaderManager::getDataLoaderOk));
}
void destroyDataLoaderSuccess() {
ON_CALL(*this, destroyDataLoader(_))
.WillByDefault(Invoke(this, &MockDataLoaderManager::destroyDataLoaderOk));
void unbindFromDataLoaderSuccess() {
ON_CALL(*this, unbindFromDataLoader(_))
.WillByDefault(Invoke(this, &MockDataLoaderManager::unbindFromDataLoaderOk));
}
binder::Status initializeDataLoaderOk(int32_t mountId, const DataLoaderParamsParcel& params,
const FileSystemControlParcel& control,
const sp<IDataLoaderStatusListener>& listener,
bool* _aidl_return) {
binder::Status bindToDataLoaderOk(int32_t mountId, const DataLoaderParamsParcel& params,
const sp<IDataLoaderStatusListener>& listener,
bool* _aidl_return) {
mId = mountId;
mListener = listener;
mServiceConnector = control.service;
mDataLoader = mDataLoaderHolder;
*_aidl_return = true;
return mDataLoader->create(mountId, params, control, listener);
if (mListener) {
mListener->onStatusChanged(mId, IDataLoaderStatusListener::DATA_LOADER_BOUND);
}
return binder::Status::ok();
}
binder::Status getDataLoaderOk(int32_t mountId, sp<IDataLoader>* _aidl_return) {
*_aidl_return = mDataLoader;
@@ -234,7 +242,7 @@ public:
void setDataLoaderStatusDestroyed() {
mListener->onStatusChanged(mId, IDataLoaderStatusListener::DATA_LOADER_DESTROYED);
}
binder::Status destroyDataLoaderOk(int32_t id) {
binder::Status unbindFromDataLoaderOk(int32_t id) {
if (mDataLoader) {
if (auto status = mDataLoader->destroy(id); !status.isOk()) {
return status;
@@ -246,17 +254,10 @@ public:
}
return binder::Status::ok();
}
int32_t setStorageParams(bool enableReadLogs) {
int32_t result = -1;
EXPECT_NE(mServiceConnector.get(), nullptr);
EXPECT_TRUE(mServiceConnector->setStorageParams(enableReadLogs, &result).isOk());
return result;
}
private:
int mId;
sp<IDataLoaderStatusListener> mListener;
sp<IIncrementalServiceConnector> mServiceConnector;
sp<IDataLoader> mDataLoader;
sp<IDataLoader> mDataLoaderHolder;
};
@@ -403,7 +404,7 @@ public:
mRootDir.path);
mDataLoaderParcel.packageName = "com.test";
mDataLoaderParcel.arguments = "uri";
mDataLoaderManager->destroyDataLoaderSuccess();
mDataLoaderManager->unbindFromDataLoaderSuccess();
mIncrementalService->onSystemReady();
}
@@ -442,7 +443,7 @@ protected:
TEST_F(IncrementalServiceTest, testCreateStorageMountIncFsFails) {
mVold->mountIncFsFails();
EXPECT_CALL(*mDataLoaderManager, initializeDataLoader(_, _, _, _, _)).Times(0);
EXPECT_CALL(*mDataLoaderManager, bindToDataLoader(_, _, _, _)).Times(0);
TemporaryDir tempDir;
int storageId =
mIncrementalService->createStorage(tempDir.path, std::move(mDataLoaderParcel), {},
@@ -452,8 +453,8 @@ TEST_F(IncrementalServiceTest, testCreateStorageMountIncFsFails) {
TEST_F(IncrementalServiceTest, testCreateStorageMountIncFsInvalidControlParcel) {
mVold->mountIncFsInvalidControlParcel();
EXPECT_CALL(*mDataLoaderManager, initializeDataLoader(_, _, _, _, _)).Times(0);
EXPECT_CALL(*mDataLoaderManager, destroyDataLoader(_)).Times(0);
EXPECT_CALL(*mDataLoaderManager, bindToDataLoader(_, _, _, _)).Times(0);
EXPECT_CALL(*mDataLoaderManager, unbindFromDataLoader(_)).Times(0);
TemporaryDir tempDir;
int storageId =
mIncrementalService->createStorage(tempDir.path, std::move(mDataLoaderParcel), {},
@@ -464,8 +465,8 @@ TEST_F(IncrementalServiceTest, testCreateStorageMountIncFsInvalidControlParcel)
TEST_F(IncrementalServiceTest, testCreateStorageMakeFileFails) {
mVold->mountIncFsSuccess();
mIncFs->makeFileFails();
EXPECT_CALL(*mDataLoaderManager, initializeDataLoader(_, _, _, _, _)).Times(0);
EXPECT_CALL(*mDataLoaderManager, destroyDataLoader(_)).Times(0);
EXPECT_CALL(*mDataLoaderManager, bindToDataLoader(_, _, _, _)).Times(0);
EXPECT_CALL(*mDataLoaderManager, unbindFromDataLoader(_)).Times(0);
EXPECT_CALL(*mVold, unmountIncFs(_));
TemporaryDir tempDir;
int storageId =
@@ -478,8 +479,8 @@ TEST_F(IncrementalServiceTest, testCreateStorageBindMountFails) {
mVold->mountIncFsSuccess();
mIncFs->makeFileSuccess();
mVold->bindMountFails();
EXPECT_CALL(*mDataLoaderManager, initializeDataLoader(_, _, _, _, _)).Times(0);
EXPECT_CALL(*mDataLoaderManager, destroyDataLoader(_)).Times(0);
EXPECT_CALL(*mDataLoaderManager, bindToDataLoader(_, _, _, _)).Times(0);
EXPECT_CALL(*mDataLoaderManager, unbindFromDataLoader(_)).Times(0);
EXPECT_CALL(*mVold, unmountIncFs(_));
TemporaryDir tempDir;
int storageId =
@@ -492,9 +493,9 @@ TEST_F(IncrementalServiceTest, testCreateStoragePrepareDataLoaderFails) {
mVold->mountIncFsSuccess();
mIncFs->makeFileSuccess();
mVold->bindMountSuccess();
mDataLoaderManager->initializeDataLoaderFails();
EXPECT_CALL(*mDataLoaderManager, initializeDataLoader(_, _, _, _, _)).Times(1);
EXPECT_CALL(*mDataLoaderManager, destroyDataLoader(_)).Times(0);
mDataLoaderManager->bindToDataLoaderFails();
EXPECT_CALL(*mDataLoaderManager, bindToDataLoader(_, _, _, _)).Times(1);
EXPECT_CALL(*mDataLoaderManager, unbindFromDataLoader(_)).Times(0);
EXPECT_CALL(*mDataLoader, create(_, _, _, _)).Times(0);
EXPECT_CALL(*mDataLoader, start(_)).Times(0);
EXPECT_CALL(*mDataLoader, destroy(_)).Times(0);
@@ -510,9 +511,10 @@ TEST_F(IncrementalServiceTest, testDeleteStorageSuccess) {
mVold->mountIncFsSuccess();
mIncFs->makeFileSuccess();
mVold->bindMountSuccess();
mDataLoaderManager->initializeDataLoaderSuccess();
EXPECT_CALL(*mDataLoaderManager, initializeDataLoader(_, _, _, _, _)).Times(1);
EXPECT_CALL(*mDataLoaderManager, destroyDataLoader(_)).Times(1);
mDataLoaderManager->bindToDataLoaderSuccess();
mDataLoaderManager->getDataLoaderSuccess();
EXPECT_CALL(*mDataLoaderManager, bindToDataLoader(_, _, _, _)).Times(1);
EXPECT_CALL(*mDataLoaderManager, unbindFromDataLoader(_)).Times(1);
EXPECT_CALL(*mDataLoader, create(_, _, _, _)).Times(1);
EXPECT_CALL(*mDataLoader, start(_)).Times(0);
EXPECT_CALL(*mDataLoader, destroy(_)).Times(1);
@@ -529,10 +531,10 @@ TEST_F(IncrementalServiceTest, testDataLoaderDestroyed) {
mVold->mountIncFsSuccess();
mIncFs->makeFileSuccess();
mVold->bindMountSuccess();
mDataLoaderManager->initializeDataLoaderSuccess();
mDataLoaderManager->bindToDataLoaderSuccess();
mDataLoaderManager->getDataLoaderSuccess();
EXPECT_CALL(*mDataLoaderManager, initializeDataLoader(_, _, _, _, _)).Times(2);
EXPECT_CALL(*mDataLoaderManager, destroyDataLoader(_)).Times(1);
EXPECT_CALL(*mDataLoaderManager, bindToDataLoader(_, _, _, _)).Times(2);
EXPECT_CALL(*mDataLoaderManager, unbindFromDataLoader(_)).Times(1);
EXPECT_CALL(*mDataLoader, create(_, _, _, _)).Times(2);
EXPECT_CALL(*mDataLoader, start(_)).Times(0);
EXPECT_CALL(*mDataLoader, destroy(_)).Times(1);
@@ -551,10 +553,10 @@ TEST_F(IncrementalServiceTest, testStartDataLoaderCreate) {
mIncFs->makeFileSuccess();
mVold->bindMountSuccess();
mDataLoader->initializeCreateOkNoStatus();
mDataLoaderManager->initializeDataLoaderSuccess();
mDataLoaderManager->bindToDataLoaderSuccess();
mDataLoaderManager->getDataLoaderSuccess();
EXPECT_CALL(*mDataLoaderManager, initializeDataLoader(_, _, _, _, _)).Times(1);
EXPECT_CALL(*mDataLoaderManager, destroyDataLoader(_)).Times(1);
EXPECT_CALL(*mDataLoaderManager, bindToDataLoader(_, _, _, _)).Times(1);
EXPECT_CALL(*mDataLoaderManager, unbindFromDataLoader(_)).Times(1);
EXPECT_CALL(*mDataLoader, create(_, _, _, _)).Times(1);
EXPECT_CALL(*mDataLoader, start(_)).Times(1);
EXPECT_CALL(*mDataLoader, destroy(_)).Times(1);
@@ -574,10 +576,10 @@ TEST_F(IncrementalServiceTest, testStartDataLoaderPendingStart) {
mIncFs->makeFileSuccess();
mVold->bindMountSuccess();
mDataLoader->initializeCreateOkNoStatus();
mDataLoaderManager->initializeDataLoaderSuccess();
mDataLoaderManager->bindToDataLoaderSuccess();
mDataLoaderManager->getDataLoaderSuccess();
EXPECT_CALL(*mDataLoaderManager, initializeDataLoader(_, _, _, _, _)).Times(2);
EXPECT_CALL(*mDataLoaderManager, destroyDataLoader(_)).Times(1);
EXPECT_CALL(*mDataLoaderManager, bindToDataLoader(_, _, _, _)).Times(1);
EXPECT_CALL(*mDataLoaderManager, unbindFromDataLoader(_)).Times(1);
EXPECT_CALL(*mDataLoader, create(_, _, _, _)).Times(2);
EXPECT_CALL(*mDataLoader, start(_)).Times(1);
EXPECT_CALL(*mDataLoader, destroy(_)).Times(1);
@@ -596,10 +598,10 @@ TEST_F(IncrementalServiceTest, testSetIncFsMountOptionsSuccess) {
mIncFs->makeFileSuccess();
mVold->bindMountSuccess();
mVold->setIncFsMountOptionsSuccess();
mDataLoaderManager->initializeDataLoaderSuccess();
mDataLoaderManager->bindToDataLoaderSuccess();
mDataLoaderManager->getDataLoaderSuccess();
mAppOpsManager->checkPermissionSuccess();
EXPECT_CALL(*mDataLoaderManager, destroyDataLoader(_));
EXPECT_CALL(*mDataLoaderManager, unbindFromDataLoader(_));
EXPECT_CALL(*mVold, unmountIncFs(_)).Times(2);
// We are calling setIncFsMountOptions(true).
EXPECT_CALL(*mVold, setIncFsMountOptions(_, true)).Times(1);
@@ -612,7 +614,7 @@ TEST_F(IncrementalServiceTest, testSetIncFsMountOptionsSuccess) {
mIncrementalService->createStorage(tempDir.path, std::move(mDataLoaderParcel), {},
IncrementalService::CreateOptions::CreateNew);
ASSERT_GE(storageId, 0);
ASSERT_GE(mDataLoaderManager->setStorageParams(true), 0);
ASSERT_GE(mDataLoader->setStorageParams(true), 0);
}
TEST_F(IncrementalServiceTest, testSetIncFsMountOptionsSuccessAndPermissionChanged) {
@@ -620,11 +622,11 @@ TEST_F(IncrementalServiceTest, testSetIncFsMountOptionsSuccessAndPermissionChang
mIncFs->makeFileSuccess();
mVold->bindMountSuccess();
mVold->setIncFsMountOptionsSuccess();
mDataLoaderManager->initializeDataLoaderSuccess();
mDataLoaderManager->bindToDataLoaderSuccess();
mDataLoaderManager->getDataLoaderSuccess();
mAppOpsManager->checkPermissionSuccess();
mAppOpsManager->initializeStartWatchingMode();
EXPECT_CALL(*mDataLoaderManager, destroyDataLoader(_));
EXPECT_CALL(*mDataLoaderManager, unbindFromDataLoader(_));
EXPECT_CALL(*mVold, unmountIncFs(_)).Times(2);
// We are calling setIncFsMountOptions(true).
EXPECT_CALL(*mVold, setIncFsMountOptions(_, true)).Times(1);
@@ -639,7 +641,7 @@ TEST_F(IncrementalServiceTest, testSetIncFsMountOptionsSuccessAndPermissionChang
mIncrementalService->createStorage(tempDir.path, std::move(mDataLoaderParcel), {},
IncrementalService::CreateOptions::CreateNew);
ASSERT_GE(storageId, 0);
ASSERT_GE(mDataLoaderManager->setStorageParams(true), 0);
ASSERT_GE(mDataLoader->setStorageParams(true), 0);
ASSERT_NE(nullptr, mAppOpsManager->mStoredCallback.get());
mAppOpsManager->mStoredCallback->opChanged(0, {});
}
@@ -648,10 +650,10 @@ TEST_F(IncrementalServiceTest, testSetIncFsMountOptionsCheckPermissionFails) {
mVold->mountIncFsSuccess();
mIncFs->makeFileSuccess();
mVold->bindMountSuccess();
mDataLoaderManager->initializeDataLoaderSuccess();
mDataLoaderManager->bindToDataLoaderSuccess();
mDataLoaderManager->getDataLoaderSuccess();
mAppOpsManager->checkPermissionFails();
EXPECT_CALL(*mDataLoaderManager, destroyDataLoader(_));
EXPECT_CALL(*mDataLoaderManager, unbindFromDataLoader(_));
EXPECT_CALL(*mVold, unmountIncFs(_)).Times(2);
// checkPermission fails, no calls to set opitions, start or stop WatchingMode.
EXPECT_CALL(*mVold, setIncFsMountOptions(_, true)).Times(0);
@@ -662,7 +664,7 @@ TEST_F(IncrementalServiceTest, testSetIncFsMountOptionsCheckPermissionFails) {
mIncrementalService->createStorage(tempDir.path, std::move(mDataLoaderParcel), {},
IncrementalService::CreateOptions::CreateNew);
ASSERT_GE(storageId, 0);
ASSERT_LT(mDataLoaderManager->setStorageParams(true), 0);
ASSERT_LT(mDataLoader->setStorageParams(true), 0);
}
TEST_F(IncrementalServiceTest, testSetIncFsMountOptionsFails) {
@@ -670,10 +672,10 @@ TEST_F(IncrementalServiceTest, testSetIncFsMountOptionsFails) {
mIncFs->makeFileSuccess();
mVold->bindMountSuccess();
mVold->setIncFsMountOptionsFails();
mDataLoaderManager->initializeDataLoaderSuccess();
mDataLoaderManager->bindToDataLoaderSuccess();
mDataLoaderManager->getDataLoaderSuccess();
mAppOpsManager->checkPermissionSuccess();
EXPECT_CALL(*mDataLoaderManager, destroyDataLoader(_));
EXPECT_CALL(*mDataLoaderManager, unbindFromDataLoader(_));
EXPECT_CALL(*mVold, unmountIncFs(_)).Times(2);
// We are calling setIncFsMountOptions.
EXPECT_CALL(*mVold, setIncFsMountOptions(_, true)).Times(1);
@@ -685,14 +687,14 @@ TEST_F(IncrementalServiceTest, testSetIncFsMountOptionsFails) {
mIncrementalService->createStorage(tempDir.path, std::move(mDataLoaderParcel), {},
IncrementalService::CreateOptions::CreateNew);
ASSERT_GE(storageId, 0);
ASSERT_LT(mDataLoaderManager->setStorageParams(true), 0);
ASSERT_LT(mDataLoader->setStorageParams(true), 0);
}
TEST_F(IncrementalServiceTest, testMakeDirectory) {
mVold->mountIncFsSuccess();
mIncFs->makeFileSuccess();
mVold->bindMountSuccess();
mDataLoaderManager->initializeDataLoaderSuccess();
mDataLoaderManager->bindToDataLoaderSuccess();
mDataLoaderManager->getDataLoaderSuccess();
TemporaryDir tempDir;
int storageId =
@@ -716,7 +718,7 @@ TEST_F(IncrementalServiceTest, testMakeDirectories) {
mVold->mountIncFsSuccess();
mIncFs->makeFileSuccess();
mVold->bindMountSuccess();
mDataLoaderManager->initializeDataLoaderSuccess();
mDataLoaderManager->bindToDataLoaderSuccess();
mDataLoaderManager->getDataLoaderSuccess();
TemporaryDir tempDir;
int storageId =