shrinker: convert remaining shrinkers to count/scan API (70534a73) · Commits · e / devices / android_kernel_sony_msm8998

arch/x86/kvm/mmu.c

+18 −7

Original line number	Original line	Diff line number	Diff line
	@@ -4421,13 +4421,12 @@ void kvm_mmu_invalidate_mmio_sptes(struct kvm *kvm)
	}		}
	}		}

	static int mmu_shrink(struct shrinker shrink, struct shrink_control sc)		static unsigned long
			mmu_shrink_scan(struct shrinker shrink, struct shrink_control sc)
	{		{
	struct kvm *kvm;		struct kvm *kvm;
	int nr_to_scan = sc->nr_to_scan;		int nr_to_scan = sc->nr_to_scan;
			unsigned long freed = 0;
	if (nr_to_scan == 0)
	goto out;

	raw_spin_lock(&kvm_lock);		raw_spin_lock(&kvm_lock);

	@@ -4462,25 +4461,37 @@ static int mmu_shrink(struct shrinker shrink, struct shrink_control sc)
	goto unlock;		goto unlock;
	}		}

	prepare_zap_oldest_mmu_page(kvm, &invalid_list);		if (prepare_zap_oldest_mmu_page(kvm, &invalid_list))
			freed++;
	kvm_mmu_commit_zap_page(kvm, &invalid_list);		kvm_mmu_commit_zap_page(kvm, &invalid_list);

	unlock:		unlock:
	spin_unlock(&kvm->mmu_lock);		spin_unlock(&kvm->mmu_lock);
	srcu_read_unlock(&kvm->srcu, idx);		srcu_read_unlock(&kvm->srcu, idx);

			/*
			* unfair on small ones
			* per-vm shrinkers cry out
			* sadness comes quickly
			*/
	list_move_tail(&kvm->vm_list, &vm_list);		list_move_tail(&kvm->vm_list, &vm_list);
	break;		break;
	}		}

	raw_spin_unlock(&kvm_lock);		raw_spin_unlock(&kvm_lock);
			return freed;

	out:		}

			static unsigned long
			mmu_shrink_count(struct shrinker shrink, struct shrink_control sc)
			{
	return percpu_counter_read_positive(&kvm_total_used_mmu_pages);		return percpu_counter_read_positive(&kvm_total_used_mmu_pages);
	}		}

	static struct shrinker mmu_shrinker = {		static struct shrinker mmu_shrinker = {
	.shrink = mmu_shrink,		.count_objects = mmu_shrink_count,
			.scan_objects = mmu_shrink_scan,
	.seeks = DEFAULT_SEEKS * 10,		.seeks = DEFAULT_SEEKS * 10,
	};		};

net/sunrpc/auth.c

+27 −14

Original line number	Original line	Diff line number	Diff line
	@@ -434,12 +434,13 @@ EXPORT_SYMBOL_GPL(rpcauth_destroy_credcache);
	/*		/*
	* Remove stale credentials. Avoid sleeping inside the loop.		* Remove stale credentials. Avoid sleeping inside the loop.
	*/		*/
	static int		static long
	rpcauth_prune_expired(struct list_head *free, int nr_to_scan)		rpcauth_prune_expired(struct list_head *free, int nr_to_scan)
	{		{
	spinlock_t *cache_lock;		spinlock_t *cache_lock;
	struct rpc_cred cred, next;		struct rpc_cred cred, next;
	unsigned long expired = jiffies - RPC_AUTH_EXPIRY_MORATORIUM;		unsigned long expired = jiffies - RPC_AUTH_EXPIRY_MORATORIUM;
			long freed = 0;

	list_for_each_entry_safe(cred, next, &cred_unused, cr_lru) {		list_for_each_entry_safe(cred, next, &cred_unused, cr_lru) {

	@@ -451,10 +452,11 @@ rpcauth_prune_expired(struct list_head *free, int nr_to_scan)
	*/		*/
	if (time_in_range(cred->cr_expire, expired, jiffies) &&		if (time_in_range(cred->cr_expire, expired, jiffies) &&
	test_bit(RPCAUTH_CRED_HASHED, &cred->cr_flags) != 0)		test_bit(RPCAUTH_CRED_HASHED, &cred->cr_flags) != 0)
	return 0;		break;

	list_del_init(&cred->cr_lru);		list_del_init(&cred->cr_lru);
	number_cred_unused--;		number_cred_unused--;
			freed++;
	if (atomic_read(&cred->cr_count) != 0)		if (atomic_read(&cred->cr_count) != 0)
	continue;		continue;

	@@ -467,29 +469,39 @@ rpcauth_prune_expired(struct list_head *free, int nr_to_scan)
	}		}
	spin_unlock(cache_lock);		spin_unlock(cache_lock);
	}		}
	return (number_cred_unused / 100) * sysctl_vfs_cache_pressure;		return freed;
	}		}

	/*		/*
	* Run memory cache shrinker.		* Run memory cache shrinker.
	*/		*/
	static int		static unsigned long
	rpcauth_cache_shrinker(struct shrinker shrink, struct shrink_control sc)		rpcauth_cache_shrink_scan(struct shrinker shrink, struct shrink_control sc)

	{		{
	LIST_HEAD(free);		LIST_HEAD(free);
	int res;		unsigned long freed;
	int nr_to_scan = sc->nr_to_scan;
	gfp_t gfp_mask = sc->gfp_mask;

	if ((gfp_mask & GFP_KERNEL) != GFP_KERNEL)		if ((sc->gfp_mask & GFP_KERNEL) != GFP_KERNEL)
	return (nr_to_scan == 0) ? 0 : -1;		return SHRINK_STOP;

			/* nothing left, don't come back */
	if (list_empty(&cred_unused))		if (list_empty(&cred_unused))
	return 0;		return SHRINK_STOP;

	spin_lock(&rpc_credcache_lock);		spin_lock(&rpc_credcache_lock);
	res = rpcauth_prune_expired(&free, nr_to_scan);		freed = rpcauth_prune_expired(&free, sc->nr_to_scan);
	spin_unlock(&rpc_credcache_lock);		spin_unlock(&rpc_credcache_lock);
	rpcauth_destroy_credlist(&free);		rpcauth_destroy_credlist(&free);
	return res;
			return freed;
			}

			static unsigned long
			rpcauth_cache_shrink_count(struct shrinker shrink, struct shrink_control sc)

			{
			return (number_cred_unused / 100) * sysctl_vfs_cache_pressure;
	}		}

	/*		/*
	@@ -805,7 +817,8 @@ rpcauth_uptodatecred(struct rpc_task *task)
	}		}

	static struct shrinker rpc_cred_shrinker = {		static struct shrinker rpc_cred_shrinker = {
	.shrink = rpcauth_cache_shrinker,		.count_objects = rpcauth_cache_shrink_count,
			.scan_objects = rpcauth_cache_shrink_scan,
	.seeks = DEFAULT_SEEKS,		.seeks = DEFAULT_SEEKS,
	};		};