Donate to e Foundation | Murena handsets with /e/OS | Own a part of Murena! Learn more

Commit 3d012cb5 authored by Hai Zhang's avatar Hai Zhang
Browse files

Avoid calling into package manager while holding permission lock. 

Since we are moving permission into mainline, the permission module
may be called with any lock held in (customized) platform code, so we
should not try to acquire any lock while holding our own lock to
prevent deadlock.

Bug: 158736025
Test: LockFinder
Test: presubmit
Change-Id: If353c03d785bddddfcf6a4d66af70d91f9a957e4
parent d32d73e4

services/core/java/com/android/server/pm/permission/PermissionManagerService.java

+163 −175
Original line number Diff line number Diff line
@@ -554,13 +554,14 @@ public class PermissionManagerService extends IPermissionManager.Stub { 
        if (mPackageManagerInt.getInstantAppPackageName(callingUid) != null) {

            return null;

        }

        final AndroidPackage pkg = mPackageManagerInt.getPackage(packageName);

        synchronized (mLock) {

            final BasePermission bp = mSettings.getPermissionLocked(permName);

            if (bp == null) {

                return null;

            }

            final int adjustedProtectionLevel = adjustPermissionProtectionFlagsLocked(

                    bp.getProtectionLevel(), packageName, callingUid);

                    bp.getProtectionLevel(), pkg, callingUid);

            return bp.generatePermissionInfo(adjustedProtectionLevel, flags);

        }

    }
@@ -2229,8 +2230,8 @@ public class PermissionManagerService extends IPermissionManager.Stub { 
        }

    }



    private int adjustPermissionProtectionFlagsLocked(

            int protectionLevel, String packageName, int uid) {

    private int adjustPermissionProtectionFlagsLocked(int protectionLevel,

            @Nullable AndroidPackage pkg, int uid) {

        // Signature permission flags area always reported

        final int protectionLevelMasked = protectionLevel

                & (PermissionInfo.PROTECTION_NORMAL
@@ -2245,8 +2246,6 @@ public class PermissionManagerService extends IPermissionManager.Stub { 
                || appId == Process.SHELL_UID) {

            return protectionLevel;

        }

        // Normalize package name to handle renamed packages and static libs

        final AndroidPackage pkg = mPackageManagerInt.getPackage(packageName);

        if (pkg == null) {

            return protectionLevel;

        }
@@ -2254,14 +2253,6 @@ public class PermissionManagerService extends IPermissionManager.Stub { 
            return protectionLevelMasked;

        }

        // Apps that target O see flags for all protection levels.

        final PackageSetting ps = (PackageSetting) mPackageManagerInt.getPackageSetting(

                pkg.getPackageName());

        if (ps == null) {

            return protectionLevel;

        }

        if (ps.getAppId() != appId) {

            return protectionLevel;

        }

        return protectionLevel;

    }
@@ -2586,8 +2577,8 @@ public class PermissionManagerService extends IPermissionManager.Stub { 
                // changed runtime permissions here are promotion of an install to

                // runtime and revocation of a runtime from a shared user.

                synchronized (mLock) {

                    updatedUserIds = revokeUnusedSharedUserPermissionsLocked(

                            ps.getSharedUser(), UserManagerService.getInstance().getUserIds());

                    updatedUserIds = revokeUnusedSharedUserPermissionsLocked(ps.getSharedUser(),

                            currentUserIds);

                    if (!ArrayUtils.isEmpty(updatedUserIds)) {

                        runtimePermissionsRevoked = true;

                    }
@@ -2597,13 +2588,12 @@ public class PermissionManagerService extends IPermissionManager.Stub { 


        permissionsState.setGlobalGids(mGlobalGids);



        synchronized (mLock) {

        ArraySet<String> newImplicitPermissions = new ArraySet<>();



        final int N = pkg.getRequestedPermissions().size();

        for (int i = 0; i < N; i++) {

            final String permName = pkg.getRequestedPermissions().get(i);

                final BasePermission bp = mSettings.getPermissionLocked(permName);

            final BasePermission bp = mSettings.getPermission(permName);

            final boolean appSupportsRuntimePermissions =

                    pkg.getTargetSdkVersion() >= Build.VERSION_CODES.M;

            String upgradedActivityRecognitionPermission = null;
@@ -2708,17 +2698,12 @@ public class PermissionManagerService extends IPermissionManager.Stub { 
                }

            } else if (bp.isSignature()) {

                // For all apps signature permissions are install time ones.

                    allowedSig = grantSignaturePermission(perm, pkg, ps, bp, origPermissions);

                allowedSig = shouldGrantSignaturePermission(perm, pkg, ps, bp, origPermissions);

                if (allowedSig) {

                    grant = GRANT_INSTALL;

                }

            }



                if (DEBUG_PERMISSIONS) {

                    Slog.i(TAG, "Considering granting permission " + perm + " to package "

                            + pkg.getPackageName());

                }



            if (grant != GRANT_DENIED) {

                if (!ps.isSystem() && ps.areInstallPermissionsFixed() && !bp.isRuntime()) {

                    // If this is an existing, non-system package, then
@@ -2733,14 +2718,22 @@ public class PermissionManagerService extends IPermissionManager.Stub { 
                        }

                    }

                }

            }



            if (DEBUG_PERMISSIONS) {

                Slog.i(TAG, "Considering granting permission " + perm + " to package "

                        + pkg.getPackageName());

            }



            synchronized (mLock) {

                if (grant != GRANT_DENIED) {

                    switch (grant) {

                        case GRANT_INSTALL: {

                            // Revoke this as runtime permission to handle the case of

                            // a runtime permission being downgraded to an install one.

                            // Also in permission review mode we keep dangerous permissions

                            // for legacy apps

                            for (int userId : UserManagerService.getInstance().getUserIds()) {

                            for (int userId : currentUserIds) {

                                if (origPermissions.getRuntimePermissionState(

                                        perm, userId) != null) {

                                    // Revoke the runtime permission and clear the flags.
@@ -3042,6 +3035,7 @@ public class PermissionManagerService extends IPermissionManager.Stub { 
                    }

                }

            }

        }



        if ((changedInstallPermission || replace) && !ps.areInstallPermissionsFixed() &&

                !ps.isSystem() || ps.getPkgState().isUpdatedSystemApp()) {
@@ -3051,11 +3045,13 @@ public class PermissionManagerService extends IPermissionManager.Stub { 
            ps.setInstallPermissionsFixed(true);

        }



        synchronized (mLock) {

            updatedUserIds = revokePermissionsNoLongerImplicitLocked(permissionsState, pkg,

                    updatedUserIds);

                    currentUserIds, updatedUserIds);

            updatedUserIds = setInitialGrantForNewImplicitPermissionsLocked(origPermissions,

                    permissionsState, pkg, newImplicitPermissions, updatedUserIds);

            updatedUserIds = checkIfLegacyStorageOpsNeedToBeUpdated(pkg, replace, updatedUserIds);

                    permissionsState, pkg, newImplicitPermissions, currentUserIds, updatedUserIds);

            updatedUserIds = checkIfLegacyStorageOpsNeedToBeUpdated(pkg, replace, currentUserIds,

                    updatedUserIds);

        }



        // Persist the runtime permissions state for users with changes. If permissions
@@ -3076,23 +3072,19 @@ public class PermissionManagerService extends IPermissionManager.Stub { 
     *

     * @param ps The state of the permissions of the package

     * @param pkg The package that is currently looked at

     * @param userIds All user IDs in the system, must be passed in because this method is locked

     * @param updatedUserIds a list of user ids that needs to be amended if the permission state

     *                       for a user is changed.

     *

     * @return The updated value of the {@code updatedUserIds} parameter

     */

    private @NonNull int[] revokePermissionsNoLongerImplicitLocked(

            @NonNull PermissionsState ps, @NonNull AndroidPackage pkg,

            @NonNull int[] updatedUserIds) {

    private @NonNull int[] revokePermissionsNoLongerImplicitLocked(@NonNull PermissionsState ps,

            @NonNull AndroidPackage pkg, @NonNull int[] userIds, @NonNull int[] updatedUserIds) {

        String pkgName = pkg.getPackageName();

        boolean supportsRuntimePermissions = pkg.getTargetSdkVersion()

                >= Build.VERSION_CODES.M;



        int[] users = UserManagerService.getInstance().getUserIds();

        int numUsers = users.length;

        for (int i = 0; i < numUsers; i++) {

            int userId = users[i];



        for (int userId : userIds) {

            for (String permission : ps.getPermissions(userId)) {

                if (!pkg.getImplicitPermissions().contains(permission)) {

                    if (!ps.hasInstallPermission(permission)) {
@@ -3188,16 +3180,17 @@ public class PermissionManagerService extends IPermissionManager.Stub { 
     *

     * @param pkg The package for which the permissions are updated

     * @param replace If the app is being replaced

     * @param userIds All user IDs in the system, must be passed in because this method is locked

     * @param updatedUserIds The ids of the users that already changed.

     *

     * @return The ids of the users that are changed

     */

    private @NonNull int[] checkIfLegacyStorageOpsNeedToBeUpdated(

            @NonNull AndroidPackage pkg, boolean replace, @NonNull int[] updatedUserIds) {

    private @NonNull int[] checkIfLegacyStorageOpsNeedToBeUpdated(@NonNull AndroidPackage pkg,

            boolean replace, @NonNull int[] userIds, @NonNull int[] updatedUserIds) {

        if (replace && pkg.isRequestLegacyExternalStorage() && (

                pkg.getRequestedPermissions().contains(READ_EXTERNAL_STORAGE)

                        || pkg.getRequestedPermissions().contains(WRITE_EXTERNAL_STORAGE))) {

            return UserManagerService.getInstance().getUserIds();

            return userIds.clone();

        }



        return updatedUserIds;
@@ -3209,15 +3202,15 @@ public class PermissionManagerService extends IPermissionManager.Stub { 
     * @param origPs The permission state of the package before the split

     * @param ps The new permission state

     * @param pkg The package the permission belongs to

     * @param userIds All user IDs in the system, must be passed in because this method is locked

     * @param updatedUserIds List of users for which the permission state has already been changed

     *

     * @return  List of users for which the permission state has been changed

     */

    private @NonNull int[] setInitialGrantForNewImplicitPermissionsLocked(

            @NonNull PermissionsState origPs,

            @NonNull PermissionsState ps, @NonNull AndroidPackage pkg,

            @NonNull ArraySet<String> newImplicitPermissions,

            @NonNull int[] updatedUserIds) {

            @NonNull PermissionsState origPs, @NonNull PermissionsState ps,

            @NonNull AndroidPackage pkg, @NonNull ArraySet<String> newImplicitPermissions,

            @NonNull int[] userIds, @NonNull int[] updatedUserIds) {

        String pkgName = pkg.getPackageName();

        ArrayMap<String, ArraySet<String>> newToSplitPerms = new ArrayMap<>();
@@ -3251,11 +3244,7 @@ public class PermissionManagerService extends IPermissionManager.Stub { 
                if (!ps.hasInstallPermission(newPerm)) {

                    BasePermission bp = mSettings.getPermissionLocked(newPerm);



                    int[] users = UserManagerService.getInstance().getUserIds();

                    int numUsers = users.length;

                    for (int userNum = 0; userNum < numUsers; userNum++) {

                        int userId = users[userNum];



                    for (int userId : userIds) {

                        if (!newPerm.equals(Manifest.permission.ACTIVITY_RECOGNITION)) {

                            ps.updatePermissionFlags(bp, userId,

                                    FLAG_PERMISSION_REVOKE_WHEN_REQUESTED,
@@ -3413,7 +3402,7 @@ public class PermissionManagerService extends IPermissionManager.Stub { 
        return wlPermissions != null && wlPermissions.contains(perm);

    }



    private boolean grantSignaturePermission(String perm, AndroidPackage pkg,

    private boolean shouldGrantSignaturePermission(String perm, AndroidPackage pkg,

            PackageSetting pkgSetting, BasePermission bp, PermissionsState origPermissions) {

        boolean oemPermission = bp.isOEM();

        boolean vendorPrivilegedPermission = bp.isVendorPrivileged();
@@ -4210,6 +4199,14 @@ public class PermissionManagerService extends IPermissionManager.Stub { 
                // The target package is the source of the current permission

                // Set to changed for either install or uninstall

                changed = true;

                if (needsUpdate == null) {

                    needsUpdate = new ArraySet<>(mSettings.mPermissions.size());

                }

                needsUpdate.add(bp);

            }

        }

        if (needsUpdate != null) {

            for (final BasePermission bp : needsUpdate) {

                // If the target package is being uninstalled, we need to revoke this permission

                // From all other packages

                if (pkg == null || !hasPermission(pkg, bp.getName())) {
@@ -4239,16 +4236,9 @@ public class PermissionManagerService extends IPermissionManager.Stub { 
                            }

                        });

                    }

                    it.remove();

                }

                if (needsUpdate == null) {

                    needsUpdate = new ArraySet<>(mSettings.mPermissions.size());

                }

                needsUpdate.add(bp);

            }

                    mSettings.removePermissionLocked(bp.getName());

                    continue;

                }

        if (needsUpdate != null) {

            for (final BasePermission bp : needsUpdate) {

                final AndroidPackage sourcePkg =

                        mPackageManagerInt.getPackage(bp.getSourcePackageName());

                final PackageSetting sourcePs =
@@ -5007,11 +4997,9 @@ public class PermissionManagerService extends IPermissionManager.Stub { 
        @Override

        public void onNewUserCreated(int userId) {

            mDefaultPermissionGrantPolicy.grantDefaultPermissions(userId);

            synchronized (mLock) {

            // NOTE: This adds UPDATE_PERMISSIONS_REPLACE_PKG

                PermissionManagerService.this.updateAllPermissions(

                        StorageManager.UUID_PRIVATE_INTERNAL, true, mDefaultPermissionCallback);

            }

            PermissionManagerService.this.updateAllPermissions(StorageManager.UUID_PRIVATE_INTERNAL,

                    true, mDefaultPermissionCallback);

        }



        @Override

services/core/java/com/android/server/pm/permission/PermissionSettings.java

+7 −5
Original line number Diff line number Diff line
@@ -88,6 +88,7 @@ public class PermissionSettings { 
    }



    public void addAppOpPackage(String permName, String packageName) {

        synchronized (mLock) {

            ArraySet<String> pkgs = mAppOpPermissionPackages.get(permName);

            if (pkgs == null) {

                pkgs = new ArraySet<>();
@@ -95,6 +96,7 @@ public class PermissionSettings { 
            }

            pkgs.add(packageName);

        }

    }



    /**

     * Transfers ownership of permissions from one package to another.