~hc/RK356X_SDK_RELEASE.git

..	..	@@ -59,6 +59,7 @@
59	59	#include <linux/capability.h>
60	60	#include <linux/file.h>
61	61	#include <linux/fdtable.h>
	62	+#include <linux/generic-radix-tree.h>
62	63	#include <linux/string.h>
63	64	#include <linux/seq_file.h>
64	65	#include <linux/namei.h>
..	..	@@ -92,11 +93,12 @@
92	93	#include <linux/sched/coredump.h>
93	94	#include <linux/sched/debug.h>
94	95	#include <linux/sched/stat.h>
95		-#include <linux/flex_array.h>
96	96	#include <linux/posix-timers.h>
	97	+#include <linux/time_namespace.h>
	98	+#include <linux/resctrl.h>
	99	+#include <linux/swait.h>
97	100	#include <linux/cpufreq_times.h>
98	101	#include <trace/events/oom.h>
99		-#include <linux/swait.h>
100	102	#include "internal.h"
101	103	#include "fd.h"
102	104
..	..	@@ -142,9 +144,13 @@
142	144	#define REG(NAME, MODE, fops) \
143	145	NOD(NAME, (S_IFREG\|(MODE)), NULL, &fops, {})
144	146	#define ONE(NAME, MODE, show) \
145		- NOD(NAME, (S_IFREG\|(MODE)), \
	147	+ NOD(NAME, (S_IFREG\|(MODE)), \
146	148	NULL, &proc_single_file_operations, \
147	149	{ .proc_show = show } )
	150	+#define ATTR(LSM, NAME, MODE) \
	151	+ NOD(NAME, (S_IFREG\|(MODE)), \
	152	+ NULL, &proc_pid_attr_operations, \
	153	+ { .lsm = LSM })
148	154
149	155	/*
150	156	* Count the number of hardlinks for the pid_entry table, excluding the .
..	..	@@ -401,11 +407,11 @@
401	407
402	408	static int lock_trace(struct task_struct *task)
403	409	{
404		- int err = mutex_lock_killable(&task->signal->cred_guard_mutex);
	410	+ int err = down_read_killable(&task->signal->exec_update_lock);
405	411	if (err)
406	412	return err;
407	413	if (!ptrace_may_access(task, PTRACE_MODE_ATTACH_FSCREDS)) {
408		- mutex_unlock(&task->signal->cred_guard_mutex);
	414	+ up_read(&task->signal->exec_update_lock);
409	415	return -EPERM;
410	416	}
411	417	return 0;
..	..	@@ -413,7 +419,7 @@
413	419
414	420	static void unlock_trace(struct task_struct *task)
415	421	{
416		- mutex_unlock(&task->signal->cred_guard_mutex);
	422	+ up_read(&task->signal->exec_update_lock);
417	423	}
418	424
419	425	#ifdef CONFIG_STACKTRACE
..	..	@@ -423,7 +429,6 @@
423	429	static int proc_pid_stack(struct seq_file m, struct pid_namespace ns,
424	430	struct pid pid, struct task_struct task)
425	431	{
426		- struct stack_trace trace;
427	432	unsigned long *entries;
428	433	int err;
429	434
..	..	@@ -446,20 +451,17 @@
446	451	if (!entries)
447	452	return -ENOMEM;
448	453
449		- trace.nr_entries = 0;
450		- trace.max_entries = MAX_STACK_TRACE_DEPTH;
451		- trace.entries = entries;
452		- trace.skip = 0;
453		-
454	454	err = lock_trace(task);
455	455	if (!err) {
456		- unsigned int i;
	456	+ unsigned int i, nr_entries;
457	457
458		- save_stack_trace_tsk(task, &trace);
	458	+ nr_entries = stack_trace_save_tsk(task, entries,
	459	+ MAX_STACK_TRACE_DEPTH, 0);
459	460
460		- for (i = 0; i < trace.nr_entries; i++) {
	461	+ for (i = 0; i < nr_entries; i++) {
461	462	seq_printf(m, "[<0>] %pB\n", (void *)entries[i]);
462	463	}
	464	+
463	465	unlock_trace(task);
464	466	}
465	467	kfree(entries);
..	..	@@ -476,7 +478,7 @@
476	478	struct pid pid, struct task_struct task)
477	479	{
478	480	if (unlikely(!sched_info_on()))
479		- seq_printf(m, "0 0 0\n");
	481	+ seq_puts(m, "0 0 0\n");
480	482	else
481	483	seq_printf(m, "%llu %llu %lu\n",
482	484	(unsigned long long)task->se.sum_exec_runtime,
..	..	@@ -505,9 +507,8 @@
505	507	lr->count, lr->time, lr->max);
506	508	for (q = 0; q < LT_BACKTRACEDEPTH; q++) {
507	509	unsigned long bt = lr->backtrace[q];
	510	+
508	511	if (!bt)
509		- break;
510		- if (bt == ULONG_MAX)
511	512	break;
512	513	seq_printf(m, " %ps", (void *)bt);
513	514	}
..	..	@@ -531,7 +532,7 @@
531	532
532	533	if (!task)
533	534	return -ESRCH;
534		- clear_all_latency_tracing(task);
	535	+ clear_tsk_latency_tracing(task);
535	536	put_task_struct(task);
536	537
537	538	return count;
..	..	@@ -550,11 +551,19 @@
550	551	static int proc_oom_score(struct seq_file m, struct pid_namespace ns,
551	552	struct pid pid, struct task_struct task)
552	553	{
553		- unsigned long totalpages = totalram_pages + total_swap_pages;
	554	+ unsigned long totalpages = totalram_pages() + total_swap_pages;
554	555	unsigned long points = 0;
	556	+ long badness;
555	557
556		- points = oom_badness(task, NULL, NULL, totalpages) *
557		- 1000 / totalpages;
	558	+ badness = oom_badness(task, totalpages);
	559	+ /*
	560	+ * Special case OOM_SCORE_ADJ_MIN for all others scale the
	561	+ * badness value into [0, 2000] range which we have been
	562	+ * exporting for a long time so userspace might depend on it.
	563	+ */
	564	+ if (badness != LONG_MIN)
	565	+ points = (1000 + badness * 1000 / (long)totalpages) * 2 / 3;
	566	+
558	567	seq_printf(m, "%lu\n", points);
559	568
560	569	return 0;
..	..	@@ -601,8 +610,10 @@
601	610	/*
602	611	* print the file header
603	612	*/
604		- seq_printf(m, "%-25s %-20s %-20s %-10s\n",
605		- "Limit", "Soft Limit", "Hard Limit", "Units");
	613	+ seq_puts(m, "Limit "
	614	+ "Soft Limit "
	615	+ "Hard Limit "
	616	+ "Units \n");
606	617
607	618	for (i = 0; i < RLIM_NLIMITS; i++) {
608	619	if (rlim[i].rlim_cur == RLIM_INFINITY)
..	..	@@ -630,24 +641,25 @@
630	641	static int proc_pid_syscall(struct seq_file m, struct pid_namespace ns,
631	642	struct pid pid, struct task_struct task)
632	643	{
633		- long nr;
634		- unsigned long args[6], sp, pc;
	644	+ struct syscall_info info;
	645	+ u64 *args = &info.data.args[0];
635	646	int res;
636	647
637	648	res = lock_trace(task);
638	649	if (res)
639	650	return res;
640	651
641		- if (task_current_syscall(task, &nr, args, 6, &sp, &pc))
	652	+ if (task_current_syscall(task, &info))
642	653	seq_puts(m, "running\n");
643		- else if (nr < 0)
644		- seq_printf(m, "%ld 0x%lx 0x%lx\n", nr, sp, pc);
	654	+ else if (info.data.nr < 0)
	655	+ seq_printf(m, "%d 0x%llx 0x%llx\n",
	656	+ info.data.nr, info.sp, info.data.instruction_pointer);
645	657	else
646	658	seq_printf(m,
647		- "%ld 0x%lx 0x%lx 0x%lx 0x%lx 0x%lx 0x%lx 0x%lx 0x%lx\n",
648		- nr,
	659	+ "%d 0x%llx 0x%llx 0x%llx 0x%llx 0x%llx 0x%llx 0x%llx 0x%llx\n",
	660	+ info.data.nr,
649	661	args[0], args[1], args[2], args[3], args[4], args[5],
650		- sp, pc);
	662	+ info.sp, info.data.instruction_pointer);
651	663	unlock_trace(task);
652	664
653	665	return 0;
..	..	@@ -696,13 +708,21 @@
696	708	* May current process learn task's sched/cmdline info (for hide_pid_min=1)
697	709	* or euid/egid (for hide_pid_min=2)?
698	710	*/
699		-static bool has_pid_permissions(struct pid_namespace *pid,
	711	+static bool has_pid_permissions(struct proc_fs_info *fs_info,
700	712	struct task_struct *task,
701		- int hide_pid_min)
	713	+ enum proc_hidepid hide_pid_min)
702	714	{
703		- if (pid->hide_pid < hide_pid_min)
	715	+ /*
	716	+ * If 'hidpid' mount option is set force a ptrace check,
	717	+ * we indicate that we are using a filesystem syscall
	718	+ * by passing PTRACE_MODE_READ_FSCREDS
	719	+ */
	720	+ if (fs_info->hide_pid == HIDEPID_NOT_PTRACEABLE)
	721	+ return ptrace_may_access(task, PTRACE_MODE_READ_FSCREDS);
	722	+
	723	+ if (fs_info->hide_pid < hide_pid_min)
704	724	return true;
705		- if (in_group_p(pid->pid_gid))
	725	+ if (in_group_p(fs_info->pid_gid))
706	726	return true;
707	727	return ptrace_may_access(task, PTRACE_MODE_READ_FSCREDS);
708	728	}
..	..	@@ -710,18 +730,18 @@
710	730
711	731	static int proc_pid_permission(struct inode *inode, int mask)
712	732	{
713		- struct pid_namespace *pid = proc_pid_ns(inode);
	733	+ struct proc_fs_info *fs_info = proc_sb_info(inode->i_sb);
714	734	struct task_struct *task;
715	735	bool has_perms;
716	736
717	737	task = get_proc_task(inode);
718	738	if (!task)
719	739	return -ESRCH;
720		- has_perms = has_pid_permissions(pid, task, HIDEPID_NO_ACCESS);
	740	+ has_perms = has_pid_permissions(fs_info, task, HIDEPID_NO_ACCESS);
721	741	put_task_struct(task);
722	742
723	743	if (!has_perms) {
724		- if (pid->hide_pid == HIDEPID_INVISIBLE) {
	744	+ if (fs_info->hide_pid == HIDEPID_INVISIBLE) {
725	745	/*
726	746	* Let's make getdents(), stat(), and open()
727	747	* consistent with each other. If a process
..	..	@@ -745,7 +765,7 @@
745	765	static int proc_single_show(struct seq_file m, void v)
746	766	{
747	767	struct inode *inode = m->private;
748		- struct pid_namespace *ns = proc_pid_ns(inode);
	768	+ struct pid_namespace *ns = proc_pid_ns(inode->i_sb);
749	769	struct pid *pid = proc_pid(inode);
750	770	struct task_struct *task;
751	771	int ret;
..	..	@@ -1031,6 +1051,8 @@
1031	1051	oom_adj = (task->signal->oom_score_adj * -OOM_DISABLE) /
1032	1052	OOM_SCORE_ADJ_MAX;
1033	1053	put_task_struct(task);
	1054	+ if (oom_adj > OOM_ADJUST_MAX)
	1055	+ oom_adj = OOM_ADJUST_MAX;
1034	1056	len = snprintf(buffer, sizeof(buffer), "%d\n", oom_adj);
1035	1057	return simple_read_from_buffer(buf, count, ppos, buffer, len);
1036	1058	}
..	..	@@ -1223,7 +1245,7 @@
1223	1245	.llseek = default_llseek,
1224	1246	};
1225	1247
1226		-#ifdef CONFIG_AUDITSYSCALL
	1248	+#ifdef CONFIG_AUDIT
1227	1249	#define TMPBUFLEN 11
1228	1250	static ssize_t proc_loginuid_read(struct file * file, char __user * buf,
1229	1251	size_t count, loff_t *ppos)
..	..	@@ -1249,6 +1271,10 @@
1249	1271	uid_t loginuid;
1250	1272	kuid_t kloginuid;
1251	1273	int rv;
	1274	+
	1275	+ /* Don't let kthreads write their own loginuid */
	1276	+ if (current->flags & PF_KTHREAD)
	1277	+ return -EPERM;
1252	1278
1253	1279	rcu_read_lock();
1254	1280	if (current != pid_task(proc_pid(inode), PIDTYPE_PID)) {
..	..	@@ -1413,7 +1439,7 @@
1413	1439	static int sched_show(struct seq_file m, void v)
1414	1440	{
1415	1441	struct inode *inode = m->private;
1416		- struct pid_namespace *ns = proc_pid_ns(inode);
	1442	+ struct pid_namespace *ns = proc_pid_ns(inode->i_sb);
1417	1443	struct task_struct *p;
1418	1444
1419	1445	p = get_proc_task(inode);
..	..	@@ -1533,6 +1559,108 @@
1533	1559
1534	1560	#endif /* CONFIG_SCHED_AUTOGROUP */
1535	1561
	1562	+#ifdef CONFIG_TIME_NS
	1563	+static int timens_offsets_show(struct seq_file m, void v)
	1564	+{
	1565	+ struct task_struct *p;
	1566	+
	1567	+ p = get_proc_task(file_inode(m->file));
	1568	+ if (!p)
	1569	+ return -ESRCH;
	1570	+ proc_timens_show_offsets(p, m);
	1571	+
	1572	+ put_task_struct(p);
	1573	+
	1574	+ return 0;
	1575	+}
	1576	+
	1577	+static ssize_t timens_offsets_write(struct file file, const char __user buf,
	1578	+ size_t count, loff_t *ppos)
	1579	+{
	1580	+ struct inode *inode = file_inode(file);
	1581	+ struct proc_timens_offset offsets[2];
	1582	+ char kbuf = NULL, pos, *next_line;
	1583	+ struct task_struct *p;
	1584	+ int ret, noffsets;
	1585	+
	1586	+ /* Only allow < page size writes at the beginning of the file */
	1587	+ if ((*ppos != 0) \|\| (count >= PAGE_SIZE))
	1588	+ return -EINVAL;
	1589	+
	1590	+ /* Slurp in the user data */
	1591	+ kbuf = memdup_user_nul(buf, count);
	1592	+ if (IS_ERR(kbuf))
	1593	+ return PTR_ERR(kbuf);
	1594	+
	1595	+ /* Parse the user data */
	1596	+ ret = -EINVAL;
	1597	+ noffsets = 0;
	1598	+ for (pos = kbuf; pos; pos = next_line) {
	1599	+ struct proc_timens_offset *off = &offsets[noffsets];
	1600	+ char clock[10];
	1601	+ int err;
	1602	+
	1603	+ /* Find the end of line and ensure we don't look past it */
	1604	+ next_line = strchr(pos, '\n');
	1605	+ if (next_line) {
	1606	+ *next_line = '\0';
	1607	+ next_line++;
	1608	+ if (*next_line == '\0')
	1609	+ next_line = NULL;
	1610	+ }
	1611	+
	1612	+ err = sscanf(pos, "%9s %lld %lu", clock,
	1613	+ &off->val.tv_sec, &off->val.tv_nsec);
	1614	+ if (err != 3 \|\| off->val.tv_nsec >= NSEC_PER_SEC)
	1615	+ goto out;
	1616	+
	1617	+ clock[sizeof(clock) - 1] = 0;
	1618	+ if (strcmp(clock, "monotonic") == 0 \|\|
	1619	+ strcmp(clock, __stringify(CLOCK_MONOTONIC)) == 0)
	1620	+ off->clockid = CLOCK_MONOTONIC;
	1621	+ else if (strcmp(clock, "boottime") == 0 \|\|
	1622	+ strcmp(clock, __stringify(CLOCK_BOOTTIME)) == 0)
	1623	+ off->clockid = CLOCK_BOOTTIME;
	1624	+ else
	1625	+ goto out;
	1626	+
	1627	+ noffsets++;
	1628	+ if (noffsets == ARRAY_SIZE(offsets)) {
	1629	+ if (next_line)
	1630	+ count = next_line - kbuf;
	1631	+ break;
	1632	+ }
	1633	+ }
	1634	+
	1635	+ ret = -ESRCH;
	1636	+ p = get_proc_task(inode);
	1637	+ if (!p)
	1638	+ goto out;
	1639	+ ret = proc_timens_set_offset(file, p, offsets, noffsets);
	1640	+ put_task_struct(p);
	1641	+ if (ret)
	1642	+ goto out;
	1643	+
	1644	+ ret = count;
	1645	+out:
	1646	+ kfree(kbuf);
	1647	+ return ret;
	1648	+}
	1649	+
	1650	+static int timens_offsets_open(struct inode inode, struct file filp)
	1651	+{
	1652	+ return single_open(filp, timens_offsets_show, inode);
	1653	+}
	1654	+
	1655	+static const struct file_operations proc_timens_offsets_operations = {
	1656	+ .open = timens_offsets_open,
	1657	+ .read = seq_read,
	1658	+ .write = timens_offsets_write,
	1659	+ .llseek = seq_lseek,
	1660	+ .release = single_release,
	1661	+};
	1662	+#endif /* CONFIG_TIME_NS */
	1663	+
1536	1664	static ssize_t comm_write(struct file file, const char __user buf,
1537	1665	size_t count, loff_t *offset)
1538	1666	{
..	..	@@ -1626,8 +1754,7 @@
1626	1754	if (error)
1627	1755	goto out;
1628	1756
1629		- nd_jump_link(&path);
1630		- return NULL;
	1757	+ error = nd_jump_link(&path);
1631	1758	out:
1632	1759	return ERR_PTR(error);
1633	1760	}
..	..	@@ -1743,11 +1870,25 @@
1743	1870	*rgid = gid;
1744	1871	}
1745	1872
	1873	+void proc_pid_evict_inode(struct proc_inode *ei)
	1874	+{
	1875	+ struct pid *pid = ei->pid;
	1876	+
	1877	+ if (S_ISDIR(ei->vfs_inode.i_mode)) {
	1878	+ spin_lock(&pid->lock);
	1879	+ hlist_del_init_rcu(&ei->sibling_inodes);
	1880	+ spin_unlock(&pid->lock);
	1881	+ }
	1882	+
	1883	+ put_pid(pid);
	1884	+}
	1885	+
1746	1886	struct inode proc_pid_make_inode(struct super_block sb,
1747	1887	struct task_struct *task, umode_t mode)
1748	1888	{
1749	1889	struct inode * inode;
1750	1890	struct proc_inode *ei;
	1891	+ struct pid *pid;
1751	1892
1752	1893	/* We need a new inode */
1753	1894
..	..	@@ -1765,9 +1906,17 @@
1765	1906	/*
1766	1907	* grab the reference to task.
1767	1908	*/
1768		- ei->pid = get_task_pid(task, PIDTYPE_PID);
1769		- if (!ei->pid)
	1909	+ pid = get_task_pid(task, PIDTYPE_PID);
	1910	+ if (!pid)
1770	1911	goto out_unlock;
	1912	+
	1913	+ /* Let the pid remember us for quick removal */
	1914	+ ei->pid = pid;
	1915	+ if (S_ISDIR(mode)) {
	1916	+ spin_lock(&pid->lock);
	1917	+ hlist_add_head_rcu(&ei->sibling_inodes, &pid->inodes);
	1918	+ spin_unlock(&pid->lock);
	1919	+ }
1771	1920
1772	1921	task_dump_owner(task, 0, &inode->i_uid, &inode->i_gid);
1773	1922	security_task_to_inode(task, inode);
..	..	@@ -1784,7 +1933,7 @@
1784	1933	u32 request_mask, unsigned int query_flags)
1785	1934	{
1786	1935	struct inode *inode = d_inode(path->dentry);
1787		- struct pid_namespace *pid = proc_pid_ns(inode);
	1936	+ struct proc_fs_info *fs_info = proc_sb_info(inode->i_sb);
1788	1937	struct task_struct *task;
1789	1938
1790	1939	generic_fillattr(inode, stat);
..	..	@@ -1794,7 +1943,7 @@
1794	1943	rcu_read_lock();
1795	1944	task = pid_task(proc_pid(inode), PIDTYPE_PID);
1796	1945	if (task) {
1797		- if (!has_pid_permissions(pid, task, HIDEPID_INVISIBLE)) {
	1946	+ if (!has_pid_permissions(fs_info, task, HIDEPID_INVISIBLE)) {
1798	1947	rcu_read_unlock();
1799	1948	/*
1800	1949	* This doesn't prevent learning whether PID exists,
..	..	@@ -1979,11 +2128,11 @@
1979	2128	goto out;
1980	2129
1981	2130	if (!dname_to_vma_addr(dentry, &vm_start, &vm_end)) {
1982		- status = down_read_killable(&mm->mmap_sem);
	2131	+ status = mmap_read_lock_killable(mm);
1983	2132	if (!status) {
1984	2133	exact_vma_exists = !!find_exact_vma(mm, vm_start,
1985	2134	vm_end);
1986		- up_read(&mm->mmap_sem);
	2135	+ mmap_read_unlock(mm);
1987	2136	}
1988	2137	}
1989	2138
..	..	@@ -2030,7 +2179,7 @@
2030	2179	if (rc)
2031	2180	goto out_mmput;
2032	2181
2033		- rc = down_read_killable(&mm->mmap_sem);
	2182	+ rc = mmap_read_lock_killable(mm);
2034	2183	if (rc)
2035	2184	goto out_mmput;
2036	2185
..	..	@@ -2041,7 +2190,7 @@
2041	2190	path_get(path);
2042	2191	rc = 0;
2043	2192	}
2044		- up_read(&mm->mmap_sem);
	2193	+ mmap_read_unlock(mm);
2045	2194
2046	2195	out_mmput:
2047	2196	mmput(mm);
..	..	@@ -2056,16 +2205,16 @@
2056	2205	};
2057	2206
2058	2207	/*
2059		- * Only allow CAP_SYS_ADMIN to follow the links, due to concerns about how the
2060		- * symlinks may be used to bypass permissions on ancestor directories in the
2061		- * path to the file in question.
	2208	+ * Only allow CAP_SYS_ADMIN and CAP_CHECKPOINT_RESTORE to follow the links, due
	2209	+ * to concerns about how the symlinks may be used to bypass permissions on
	2210	+ * ancestor directories in the path to the file in question.
2062	2211	*/
2063	2212	static const char *
2064	2213	proc_map_files_get_link(struct dentry *dentry,
2065	2214	struct inode *inode,
2066	2215	struct delayed_call *done)
2067	2216	{
2068		- if (!capable(CAP_SYS_ADMIN))
	2217	+ if (!checkpoint_restore_ns_capable(&init_user_ns))
2069	2218	return ERR_PTR(-EPERM);
2070	2219
2071	2220	return proc_pid_get_link(dentry, inode, done);
..	..	@@ -2131,7 +2280,7 @@
2131	2280	goto out_put_task;
2132	2281
2133	2282	result = ERR_PTR(-EINTR);
2134		- if (down_read_killable(&mm->mmap_sem))
	2283	+ if (mmap_read_lock_killable(mm))
2135	2284	goto out_put_mm;
2136	2285
2137	2286	result = ERR_PTR(-ENOENT);
..	..	@@ -2144,7 +2293,7 @@
2144	2293	(void *)(unsigned long)vma->vm_file->f_mode);
2145	2294
2146	2295	out_no_vma:
2147		- up_read(&mm->mmap_sem);
	2296	+ mmap_read_unlock(mm);
2148	2297	out_put_mm:
2149	2298	mmput(mm);
2150	2299	out_put_task:
..	..	@@ -2166,10 +2315,11 @@
2166	2315	struct task_struct *task;
2167	2316	struct mm_struct *mm;
2168	2317	unsigned long nr_files, pos, i;
2169		- struct flex_array *fa = NULL;
2170		- struct map_files_info info;
	2318	+ GENRADIX(struct map_files_info) fa;
2171	2319	struct map_files_info *p;
2172	2320	int ret;
	2321	+
	2322	+ genradix_init(&fa);
2173	2323
2174	2324	ret = -ENOENT;
2175	2325	task = get_proc_task(file_inode(file));
..	..	@@ -2188,7 +2338,7 @@
2188	2338	if (!mm)
2189	2339	goto out_put_task;
2190	2340
2191		- ret = down_read_killable(&mm->mmap_sem);
	2341	+ ret = mmap_read_lock_killable(mm);
2192	2342	if (ret) {
2193	2343	mmput(mm);
2194	2344	goto out_put_task;
..	..	@@ -2199,52 +2349,39 @@
2199	2349	/*
2200	2350	* We need two passes here:
2201	2351	*
2202		- * 1) Collect vmas of mapped files with mmap_sem taken
2203		- * 2) Release mmap_sem and instantiate entries
	2352	+ * 1) Collect vmas of mapped files with mmap_lock taken
	2353	+ * 2) Release mmap_lock and instantiate entries
2204	2354	*
2205	2355	* otherwise we get lockdep complained, since filldir()
2206		- * routine might require mmap_sem taken in might_fault().
	2356	+ * routine might require mmap_lock taken in might_fault().
2207	2357	*/
2208	2358
2209	2359	for (vma = mm->mmap, pos = 2; vma; vma = vma->vm_next) {
2210		- if (vma->vm_file && ++pos > ctx->pos)
2211		- nr_files++;
2212		- }
	2360	+ if (!vma->vm_file)
	2361	+ continue;
	2362	+ if (++pos <= ctx->pos)
	2363	+ continue;
2213	2364
2214		- if (nr_files) {
2215		- fa = flex_array_alloc(sizeof(info), nr_files,
2216		- GFP_KERNEL);
2217		- if (!fa \|\| flex_array_prealloc(fa, 0, nr_files,
2218		- GFP_KERNEL)) {
	2365	+ p = genradix_ptr_alloc(&fa, nr_files++, GFP_KERNEL);
	2366	+ if (!p) {
2219	2367	ret = -ENOMEM;
2220		- if (fa)
2221		- flex_array_free(fa);
2222		- up_read(&mm->mmap_sem);
	2368	+ mmap_read_unlock(mm);
2223	2369	mmput(mm);
2224	2370	goto out_put_task;
2225	2371	}
2226		- for (i = 0, vma = mm->mmap, pos = 2; vma;
2227		- vma = vma->vm_next) {
2228		- if (!vma->vm_file)
2229		- continue;
2230		- if (++pos <= ctx->pos)
2231		- continue;
2232	2372
2233		- info.start = vma->vm_start;
2234		- info.end = vma->vm_end;
2235		- info.mode = vma->vm_file->f_mode;
2236		- if (flex_array_put(fa, i++, &info, GFP_KERNEL))
2237		- BUG();
2238		- }
	2373	+ p->start = vma->vm_start;
	2374	+ p->end = vma->vm_end;
	2375	+ p->mode = vma->vm_file->f_mode;
2239	2376	}
2240		- up_read(&mm->mmap_sem);
	2377	+ mmap_read_unlock(mm);
2241	2378	mmput(mm);
2242	2379
2243	2380	for (i = 0; i < nr_files; i++) {
2244	2381	char buf[4 * sizeof(long) + 2]; /* max: %lx-%lx\0 */
2245	2382	unsigned int len;
2246	2383
2247		- p = flex_array_get(fa, i);
	2384	+ p = genradix_ptr(&fa, i);
2248	2385	len = snprintf(buf, sizeof(buf), "%lx-%lx", p->start, p->end);
2249	2386	if (!proc_fill_cache(file, ctx,
2250	2387	buf, len,
..	..	@@ -2254,12 +2391,11 @@
2254	2391	break;
2255	2392	ctx->pos++;
2256	2393	}
2257		- if (fa)
2258		- flex_array_free(fa);
2259	2394
2260	2395	out_put_task:
2261	2396	put_task_struct(task);
2262	2397	out:
	2398	+ genradix_free(&fa);
2263	2399	return ret;
2264	2400	}
2265	2401
..	..	@@ -2358,7 +2494,7 @@
2358	2494	return -ENOMEM;
2359	2495
2360	2496	tp->pid = proc_pid(inode);
2361		- tp->ns = proc_pid_ns(inode);
	2497	+ tp->ns = proc_pid_ns(inode->i_sb);
2362	2498	return 0;
2363	2499	}
2364	2500
..	..	@@ -2387,10 +2523,13 @@
2387	2523	return -ESRCH;
2388	2524
2389	2525	if (p != current) {
2390		- if (!capable(CAP_SYS_NICE)) {
	2526	+ rcu_read_lock();
	2527	+ if (!ns_capable(__task_cred(p)->user_ns, CAP_SYS_NICE)) {
	2528	+ rcu_read_unlock();
2391	2529	count = -EPERM;
2392	2530	goto out;
2393	2531	}
	2532	+ rcu_read_unlock();
2394	2533
2395	2534	err = security_task_setscheduler(p);
2396	2535	if (err) {
..	..	@@ -2423,11 +2562,14 @@
2423	2562	return -ESRCH;
2424	2563
2425	2564	if (p != current) {
2426		-
2427		- if (!capable(CAP_SYS_NICE)) {
	2565	+ rcu_read_lock();
	2566	+ if (!ns_capable(__task_cred(p)->user_ns, CAP_SYS_NICE)) {
	2567	+ rcu_read_unlock();
2428	2568	err = -EPERM;
2429	2569	goto out;
2430	2570	}
	2571	+ rcu_read_unlock();
	2572	+
2431	2573	err = security_task_getscheduler(p);
2432	2574	if (err)
2433	2575	goto out;
..	..	@@ -2482,11 +2624,10 @@
2482	2624
2483	2625	static struct dentry proc_pident_lookup(struct inode dir,
2484	2626	struct dentry *dentry,
2485		- const struct pid_entry *ents,
2486		- unsigned int nents)
	2627	+ const struct pid_entry *p,
	2628	+ const struct pid_entry *end)
2487	2629	{
2488	2630	struct task_struct *task = get_proc_task(dir);
2489		- const struct pid_entry p, last;
2490	2631	struct dentry *res = ERR_PTR(-ENOENT);
2491	2632
2492	2633	if (!task)
..	..	@@ -2496,8 +2637,7 @@
2496	2637	* Yes, it does not scale. And it should not. Don't add
2497	2638	* new entries into /proc/<tgid>/ without very good reasons.
2498	2639	*/
2499		- last = &ents[nents];
2500		- for (p = ents; p < last; p++) {
	2640	+ for (; p < end; p++) {
2501	2641	if (p->len != dentry->d_name.len)
2502	2642	continue;
2503	2643	if (!memcmp(dentry->d_name.name, p->name, p->len)) {
..	..	@@ -2555,7 +2695,7 @@
2555	2695	if (!task)
2556	2696	return -ESRCH;
2557	2697
2558		- length = security_getprocattr(task,
	2698	+ length = security_getprocattr(task, PROC_I(inode)->op.lsm,
2559	2699	(char*)file->f_path.dentry->d_name.name,
2560	2700	&p);
2561	2701	put_task_struct(task);
..	..	@@ -2613,7 +2753,9 @@
2613	2753	if (rv < 0)
2614	2754	goto out_free;
2615	2755
2616		- rv = security_setprocattr(file->f_path.dentry->d_name.name, page, count);
	2756	+ rv = security_setprocattr(PROC_I(inode)->op.lsm,
	2757	+ file->f_path.dentry->d_name.name, page,
	2758	+ count);
2617	2759	mutex_unlock(&current->signal->cred_guard_mutex);
2618	2760	out_free:
2619	2761	kfree(page);
..	..	@@ -2629,13 +2771,66 @@
2629	2771	.release = mem_release,
2630	2772	};
2631	2773
	2774	+#define LSM_DIR_OPS(LSM) \
	2775	+static int proc_##LSM##_attr_dir_iterate(struct file *filp, \
	2776	+ struct dir_context *ctx) \
	2777	+{ \
	2778	+ return proc_pident_readdir(filp, ctx, \
	2779	+ LSM##_attr_dir_stuff, \
	2780	+ ARRAY_SIZE(LSM##_attr_dir_stuff)); \
	2781	+} \
	2782	+\
	2783	+static const struct file_operations proc_##LSM##_attr_dir_ops = { \
	2784	+ .read = generic_read_dir, \
	2785	+ .iterate = proc_##LSM##_attr_dir_iterate, \
	2786	+ .llseek = default_llseek, \
	2787	+}; \
	2788	+\
	2789	+static struct dentry proc_##LSM##_attr_dir_lookup(struct inode dir, \
	2790	+ struct dentry *dentry, unsigned int flags) \
	2791	+{ \
	2792	+ return proc_pident_lookup(dir, dentry, \
	2793	+ LSM##_attr_dir_stuff, \
	2794	+ LSM##_attr_dir_stuff + ARRAY_SIZE(LSM##_attr_dir_stuff)); \
	2795	+} \
	2796	+\
	2797	+static const struct inode_operations proc_##LSM##_attr_dir_inode_ops = { \
	2798	+ .lookup = proc_##LSM##_attr_dir_lookup, \
	2799	+ .getattr = pid_getattr, \
	2800	+ .setattr = proc_setattr, \
	2801	+}
	2802	+
	2803	+#ifdef CONFIG_SECURITY_SMACK
	2804	+static const struct pid_entry smack_attr_dir_stuff[] = {
	2805	+ ATTR("smack", "current", 0666),
	2806	+};
	2807	+LSM_DIR_OPS(smack);
	2808	+#endif
	2809	+
	2810	+#ifdef CONFIG_SECURITY_APPARMOR
	2811	+static const struct pid_entry apparmor_attr_dir_stuff[] = {
	2812	+ ATTR("apparmor", "current", 0666),
	2813	+ ATTR("apparmor", "prev", 0444),
	2814	+ ATTR("apparmor", "exec", 0666),
	2815	+};
	2816	+LSM_DIR_OPS(apparmor);
	2817	+#endif
	2818	+
2632	2819	static const struct pid_entry attr_dir_stuff[] = {
2633		- REG("current", S_IRUGO\|S_IWUGO, proc_pid_attr_operations),
2634		- REG("prev", S_IRUGO, proc_pid_attr_operations),
2635		- REG("exec", S_IRUGO\|S_IWUGO, proc_pid_attr_operations),
2636		- REG("fscreate", S_IRUGO\|S_IWUGO, proc_pid_attr_operations),
2637		- REG("keycreate", S_IRUGO\|S_IWUGO, proc_pid_attr_operations),
2638		- REG("sockcreate", S_IRUGO\|S_IWUGO, proc_pid_attr_operations),
	2820	+ ATTR(NULL, "current", 0666),
	2821	+ ATTR(NULL, "prev", 0444),
	2822	+ ATTR(NULL, "exec", 0666),
	2823	+ ATTR(NULL, "fscreate", 0666),
	2824	+ ATTR(NULL, "keycreate", 0666),
	2825	+ ATTR(NULL, "sockcreate", 0666),
	2826	+#ifdef CONFIG_SECURITY_SMACK
	2827	+ DIR("smack", 0555,
	2828	+ proc_smack_attr_dir_inode_ops, proc_smack_attr_dir_ops),
	2829	+#endif
	2830	+#ifdef CONFIG_SECURITY_APPARMOR
	2831	+ DIR("apparmor", 0555,
	2832	+ proc_apparmor_attr_dir_inode_ops, proc_apparmor_attr_dir_ops),
	2833	+#endif
2639	2834	};
2640	2835
2641	2836	static int proc_attr_dir_readdir(struct file file, struct dir_context ctx)
..	..	@@ -2654,7 +2849,8 @@
2654	2849	struct dentry *dentry, unsigned int flags)
2655	2850	{
2656	2851	return proc_pident_lookup(dir, dentry,
2657		- attr_dir_stuff, ARRAY_SIZE(attr_dir_stuff));
	2852	+ attr_dir_stuff,
	2853	+ attr_dir_stuff + ARRAY_SIZE(attr_dir_stuff));
2658	2854	}
2659	2855
2660	2856	static const struct inode_operations proc_attr_dir_inode_operations = {
..	..	@@ -2749,7 +2945,7 @@
2749	2945	unsigned long flags;
2750	2946	int result;
2751	2947
2752		- result = mutex_lock_killable(&task->signal->cred_guard_mutex);
	2948	+ result = down_read_killable(&task->signal->exec_update_lock);
2753	2949	if (result)
2754	2950	return result;
2755	2951
..	..	@@ -2785,7 +2981,7 @@
2785	2981	result = 0;
2786	2982
2787	2983	out_unlock:
2788		- mutex_unlock(&task->signal->cred_guard_mutex);
	2984	+ up_read(&task->signal->exec_update_lock);
2789	2985	return result;
2790	2986	}
2791	2987
..	..	@@ -2954,6 +3150,21 @@
2954	3150	}
2955	3151	#endif /* CONFIG_LIVEPATCH */
2956	3152
	3153	+#ifdef CONFIG_STACKLEAK_METRICS
	3154	+static int proc_stack_depth(struct seq_file m, struct pid_namespace ns,
	3155	+ struct pid pid, struct task_struct task)
	3156	+{
	3157	+ unsigned long prev_depth = THREAD_SIZE -
	3158	+ (task->prev_lowest_stack & (THREAD_SIZE - 1));
	3159	+ unsigned long depth = THREAD_SIZE -
	3160	+ (task->lowest_stack & (THREAD_SIZE - 1));
	3161	+
	3162	+ seq_printf(m, "previous stack depth: %lu\nstack depth: %lu\n",
	3163	+ prev_depth, depth);
	3164	+ return 0;
	3165	+}
	3166	+#endif /* CONFIG_STACKLEAK_METRICS */
	3167	+
2957	3168	/*
2958	3169	* Thread groups
2959	3170	*/
..	..	@@ -2964,7 +3175,7 @@
2964	3175	DIR("task", S_IRUGO\|S_IXUGO, proc_task_inode_operations, proc_task_operations),
2965	3176	DIR("fd", S_IRUSR\|S_IXUSR, proc_fd_inode_operations, proc_fd_operations),
2966	3177	DIR("map_files", S_IRUSR\|S_IXUSR, proc_map_files_inode_operations, proc_map_files_operations),
2967		- DIR("fdinfo", S_IRUSR\|S_IXUSR, proc_fdinfo_inode_operations, proc_fdinfo_operations),
	3178	+ DIR("fdinfo", S_IRUGO\|S_IXUGO, proc_fdinfo_inode_operations, proc_fdinfo_operations),
2968	3179	DIR("ns", S_IRUSR\|S_IXUGO, proc_ns_dir_inode_operations, proc_ns_dir_operations),
2969	3180	#ifdef CONFIG_NET
2970	3181	DIR("net", S_IRUGO\|S_IXUGO, proc_net_inode_operations, proc_net_operations),
..	..	@@ -2979,6 +3190,9 @@
2979	3190	#endif
2980	3191	#ifdef CONFIG_SCHED_AUTOGROUP
2981	3192	REG("autogroup", S_IRUGO\|S_IWUSR, proc_pid_sched_autogroup_operations),
	3193	+#endif
	3194	+#ifdef CONFIG_TIME_NS
	3195	+ REG("timens_offsets", S_IRUGO\|S_IWUSR, proc_timens_offsets_operations),
2982	3196	#endif
2983	3197	REG("comm", S_IRUGO\|S_IWUSR, proc_pid_set_comm_operations),
2984	3198	#ifdef CONFIG_HAVE_ARCH_TRACEHOOK
..	..	@@ -3025,10 +3239,13 @@
3025	3239	#ifdef CONFIG_CGROUPS
3026	3240	ONE("cgroup", S_IRUGO, proc_cgroup_show),
3027	3241	#endif
	3242	+#ifdef CONFIG_PROC_CPU_RESCTRL
	3243	+ ONE("cpu_resctrl_groups", S_IRUGO, proc_resctrl_show),
	3244	+#endif
3028	3245	ONE("oom_score", S_IRUGO, proc_oom_score),
3029	3246	REG("oom_adj", S_IRUGO\|S_IWUSR, proc_oom_adj_operations),
3030	3247	REG("oom_score_adj", S_IRUGO\|S_IWUSR, proc_oom_score_adj_operations),
3031		-#ifdef CONFIG_AUDITSYSCALL
	3248	+#ifdef CONFIG_AUDIT
3032	3249	REG("loginuid", S_IWUSR\|S_IRUGO, proc_loginuid_operations),
3033	3250	REG("sessionid", S_IRUGO, proc_sessionid_operations),
3034	3251	#endif
..	..	@@ -3058,6 +3275,12 @@
3058	3275	#ifdef CONFIG_CPU_FREQ_TIMES
3059	3276	ONE("time_in_state", 0444, proc_time_in_state_show),
3060	3277	#endif
	3278	+#ifdef CONFIG_STACKLEAK_METRICS
	3279	+ ONE("stack_depth", S_IRUGO, proc_stack_depth),
	3280	+#endif
	3281	+#ifdef CONFIG_PROC_PID_ARCH_STATUS
	3282	+ ONE("arch_status", S_IRUGO, proc_pid_arch_status),
	3283	+#endif
3061	3284	};
3062	3285
3063	3286	static int proc_tgid_base_readdir(struct file file, struct dir_context ctx)
..	..	@@ -3074,8 +3297,7 @@
3074	3297
3075	3298	struct pid tgid_pidfd_to_pid(const struct file file)
3076	3299	{
3077		- if (!d_is_dir(file->f_path.dentry) \|\|
3078		- (file->f_op != &proc_tgid_base_operations))
	3300	+ if (file->f_op != &proc_tgid_base_operations)
3079	3301	return ERR_PTR(-EBADF);
3080	3302
3081	3303	return proc_pid(file_inode(file));
..	..	@@ -3084,7 +3306,8 @@
3084	3306	static struct dentry proc_tgid_base_lookup(struct inode dir, struct dentry *dentry, unsigned int flags)
3085	3307	{
3086	3308	return proc_pident_lookup(dir, dentry,
3087		- tgid_base_stuff, ARRAY_SIZE(tgid_base_stuff));
	3309	+ tgid_base_stuff,
	3310	+ tgid_base_stuff + ARRAY_SIZE(tgid_base_stuff));
3088	3311	}
3089	3312
3090	3313	static const struct inode_operations proc_tgid_base_inode_operations = {
..	..	@@ -3094,90 +3317,28 @@
3094	3317	.permission = proc_pid_permission,
3095	3318	};
3096	3319
3097		-static void proc_flush_task_mnt(struct vfsmount *mnt, pid_t pid, pid_t tgid)
3098		-{
3099		- struct dentry dentry, leader, *dir;
3100		- char buf[10 + 1];
3101		- struct qstr name;
3102		-
3103		- name.name = buf;
3104		- name.len = snprintf(buf, sizeof(buf), "%u", pid);
3105		- /* no ->d_hash() rejects on procfs */
3106		- dentry = d_hash_and_lookup(mnt->mnt_root, &name);
3107		- if (dentry) {
3108		- d_invalidate(dentry);
3109		- dput(dentry);
3110		- }
3111		-
3112		- if (pid == tgid)
3113		- return;
3114		-
3115		- name.name = buf;
3116		- name.len = snprintf(buf, sizeof(buf), "%u", tgid);
3117		- leader = d_hash_and_lookup(mnt->mnt_root, &name);
3118		- if (!leader)
3119		- goto out;
3120		-
3121		- name.name = "task";
3122		- name.len = strlen(name.name);
3123		- dir = d_hash_and_lookup(leader, &name);
3124		- if (!dir)
3125		- goto out_put_leader;
3126		-
3127		- name.name = buf;
3128		- name.len = snprintf(buf, sizeof(buf), "%u", pid);
3129		- dentry = d_hash_and_lookup(dir, &name);
3130		- if (dentry) {
3131		- d_invalidate(dentry);
3132		- dput(dentry);
3133		- }
3134		-
3135		- dput(dir);
3136		-out_put_leader:
3137		- dput(leader);
3138		-out:
3139		- return;
3140		-}
3141		-
3142	3320	/**
3143		- * proc_flush_task - Remove dcache entries for @task from the /proc dcache.
3144		- * @task: task that should be flushed.
	3321	+ * proc_flush_pid - Remove dcache entries for @pid from the /proc dcache.
	3322	+ * @pid: pid that should be flushed.
3145	3323	*
3146		- * When flushing dentries from proc, one needs to flush them from global
3147		- * proc (proc_mnt) and from all the namespaces' procs this task was seen
3148		- * in. This call is supposed to do all of this job.
3149		- *
3150		- * Looks in the dcache for
3151		- * /proc/@pid
3152		- * /proc/@tgid/task/@pid
3153		- * if either directory is present flushes it and all of it'ts children
3154		- * from the dcache.
	3324	+ * This function walks a list of inodes (that belong to any proc
	3325	+ * filesystem) that are attached to the pid and flushes them from
	3326	+ * the dentry cache.
3155	3327	*
3156	3328	* It is safe and reasonable to cache /proc entries for a task until
3157	3329	* that task exits. After that they just clog up the dcache with
3158	3330	* useless entries, possibly causing useful dcache entries to be
3159		- * flushed instead. This routine is proved to flush those useless
3160		- * dcache entries at process exit time.
	3331	+ * flushed instead. This routine is provided to flush those useless
	3332	+ * dcache entries when a process is reaped.
3161	3333	*
3162	3334	* NOTE: This routine is just an optimization so it does not guarantee
3163		- * that no dcache entries will exist at process exit time it
3164		- * just makes it very unlikely that any will persist.
	3335	+ * that no dcache entries will exist after a process is reaped
	3336	+ * it just makes it very unlikely that any will persist.
3165	3337	*/
3166	3338
3167		-void proc_flush_task(struct task_struct *task)
	3339	+void proc_flush_pid(struct pid *pid)
3168	3340	{
3169		- int i;
3170		- struct pid pid, tgid;
3171		- struct upid *upid;
3172		-
3173		- pid = task_pid(task);
3174		- tgid = task_tgid(task);
3175		-
3176		- for (i = 0; i <= pid->level; i++) {
3177		- upid = &pid->numbers[i];
3178		- proc_flush_task_mnt(upid->ns->proc_mnt, upid->nr,
3179		- tgid->numbers[i].nr);
3180		- }
	3341	+ proc_invalidate_siblings_dcache(&pid->inodes, &pid->lock);
3181	3342	}
3182	3343
3183	3344	static struct dentry proc_pid_instantiate(struct dentry dentry,
..	..	@@ -3200,10 +3361,11 @@
3200	3361	return d_splice_alias(inode, dentry);
3201	3362	}
3202	3363
3203		-struct dentry proc_pid_lookup(struct inode dir, struct dentry * dentry, unsigned int flags)
	3364	+struct dentry proc_pid_lookup(struct dentry dentry, unsigned int flags)
3204	3365	{
3205	3366	struct task_struct *task;
3206	3367	unsigned tgid;
	3368	+ struct proc_fs_info *fs_info;
3207	3369	struct pid_namespace *ns;
3208	3370	struct dentry *result = ERR_PTR(-ENOENT);
3209	3371
..	..	@@ -3211,7 +3373,8 @@
3211	3373	if (tgid == ~0U)
3212	3374	goto out;
3213	3375
3214		- ns = dentry->d_sb->s_fs_info;
	3376	+ fs_info = proc_sb_info(dentry->d_sb);
	3377	+ ns = fs_info->pid_ns;
3215	3378	rcu_read_lock();
3216	3379	task = find_task_by_pid_ns(tgid, ns);
3217	3380	if (task)
..	..	@@ -3220,7 +3383,14 @@
3220	3383	if (!task)
3221	3384	goto out;
3222	3385
	3386	+ /* Limit procfs to only ptraceable tasks */
	3387	+ if (fs_info->hide_pid == HIDEPID_NOT_PTRACEABLE) {
	3388	+ if (!has_pid_permissions(fs_info, task, HIDEPID_NO_ACCESS))
	3389	+ goto out_put_task;
	3390	+ }
	3391	+
3223	3392	result = proc_pid_instantiate(dentry, task, NULL);
	3393	+out_put_task:
3224	3394	put_task_struct(task);
3225	3395	out:
3226	3396	return result;
..	..	@@ -3246,20 +3416,8 @@
3246	3416	pid = find_ge_pid(iter.tgid, ns);
3247	3417	if (pid) {
3248	3418	iter.tgid = pid_nr_ns(pid, ns);
3249		- iter.task = pid_task(pid, PIDTYPE_PID);
3250		- /* What we to know is if the pid we have find is the
3251		- * pid of a thread_group_leader. Testing for task
3252		- * being a thread_group_leader is the obvious thing
3253		- * todo but there is a window when it fails, due to
3254		- * the pid transfer logic in de_thread.
3255		- *
3256		- * So we perform the straight forward test of seeing
3257		- * if the pid we have found is the pid of a thread
3258		- * group leader, and don't worry if the task we have
3259		- * found doesn't happen to be a thread group leader.
3260		- * As we don't care in the case of readdir.
3261		- */
3262		- if (!iter.task \|\| !has_group_leader_pid(iter.task)) {
	3419	+ iter.task = pid_task(pid, PIDTYPE_TGID);
	3420	+ if (!iter.task) {
3263	3421	iter.tgid += 1;
3264	3422	goto retry;
3265	3423	}
..	..	@@ -3275,20 +3433,21 @@
3275	3433	int proc_pid_readdir(struct file file, struct dir_context ctx)
3276	3434	{
3277	3435	struct tgid_iter iter;
3278		- struct pid_namespace *ns = proc_pid_ns(file_inode(file));
	3436	+ struct proc_fs_info *fs_info = proc_sb_info(file_inode(file)->i_sb);
	3437	+ struct pid_namespace *ns = proc_pid_ns(file_inode(file)->i_sb);
3279	3438	loff_t pos = ctx->pos;
3280	3439
3281	3440	if (pos >= PID_MAX_LIMIT + TGID_OFFSET)
3282	3441	return 0;
3283	3442
3284	3443	if (pos == TGID_OFFSET - 2) {
3285		- struct inode *inode = d_inode(ns->proc_self);
	3444	+ struct inode *inode = d_inode(fs_info->proc_self);
3286	3445	if (!dir_emit(ctx, "self", 4, inode->i_ino, DT_LNK))
3287	3446	return 0;
3288	3447	ctx->pos = pos = pos + 1;
3289	3448	}
3290	3449	if (pos == TGID_OFFSET - 1) {
3291		- struct inode *inode = d_inode(ns->proc_thread_self);
	3450	+ struct inode *inode = d_inode(fs_info->proc_thread_self);
3292	3451	if (!dir_emit(ctx, "thread-self", 11, inode->i_ino, DT_LNK))
3293	3452	return 0;
3294	3453	ctx->pos = pos = pos + 1;
..	..	@@ -3302,7 +3461,7 @@
3302	3461	unsigned int len;
3303	3462
3304	3463	cond_resched();
3305		- if (!has_pid_permissions(ns, iter.task, HIDEPID_INVISIBLE))
	3464	+ if (!has_pid_permissions(fs_info, iter.task, HIDEPID_INVISIBLE))
3306	3465	continue;
3307	3466
3308	3467	len = snprintf(name, sizeof(name), "%u", iter.tgid);
..	..	@@ -3360,7 +3519,7 @@
3360	3519	*/
3361	3520	static const struct pid_entry tid_base_stuff[] = {
3362	3521	DIR("fd", S_IRUSR\|S_IXUSR, proc_fd_inode_operations, proc_fd_operations),
3363		- DIR("fdinfo", S_IRUSR\|S_IXUSR, proc_fdinfo_inode_operations, proc_fdinfo_operations),
	3522	+ DIR("fdinfo", S_IRUGO\|S_IXUGO, proc_fdinfo_inode_operations, proc_fdinfo_operations),
3364	3523	DIR("ns", S_IRUSR\|S_IXUGO, proc_ns_dir_inode_operations, proc_ns_dir_operations),
3365	3524	#ifdef CONFIG_NET
3366	3525	DIR("net", S_IRUGO\|S_IXUGO, proc_net_inode_operations, proc_net_operations),
..	..	@@ -3422,10 +3581,13 @@
3422	3581	#ifdef CONFIG_CGROUPS
3423	3582	ONE("cgroup", S_IRUGO, proc_cgroup_show),
3424	3583	#endif
	3584	+#ifdef CONFIG_PROC_CPU_RESCTRL
	3585	+ ONE("cpu_resctrl_groups", S_IRUGO, proc_resctrl_show),
	3586	+#endif
3425	3587	ONE("oom_score", S_IRUGO, proc_oom_score),
3426	3588	REG("oom_adj", S_IRUGO\|S_IWUSR, proc_oom_adj_operations),
3427	3589	REG("oom_score_adj", S_IRUGO\|S_IWUSR, proc_oom_score_adj_operations),
3428		-#ifdef CONFIG_AUDITSYSCALL
	3590	+#ifdef CONFIG_AUDIT
3429	3591	REG("loginuid", S_IWUSR\|S_IRUGO, proc_loginuid_operations),
3430	3592	REG("sessionid", S_IRUGO, proc_sessionid_operations),
3431	3593	#endif
..	..	@@ -3445,6 +3607,9 @@
3445	3607	#ifdef CONFIG_LIVEPATCH
3446	3608	ONE("patch_state", S_IRUSR, proc_pid_patch_state),
3447	3609	#endif
	3610	+#ifdef CONFIG_PROC_PID_ARCH_STATUS
	3611	+ ONE("arch_status", S_IRUGO, proc_pid_arch_status),
	3612	+#endif
3448	3613	#ifdef CONFIG_CPU_FREQ_TIMES
3449	3614	ONE("time_in_state", 0444, proc_time_in_state_show),
3450	3615	#endif
..	..	@@ -3459,7 +3624,8 @@
3459	3624	static struct dentry proc_tid_base_lookup(struct inode dir, struct dentry *dentry, unsigned int flags)
3460	3625	{
3461	3626	return proc_pident_lookup(dir, dentry,
3462		- tid_base_stuff, ARRAY_SIZE(tid_base_stuff));
	3627	+ tid_base_stuff,
	3628	+ tid_base_stuff + ARRAY_SIZE(tid_base_stuff));
3463	3629	}
3464	3630
3465	3631	static const struct file_operations proc_tid_base_operations = {
..	..	@@ -3498,6 +3664,7 @@
3498	3664	struct task_struct *task;
3499	3665	struct task_struct *leader = get_proc_task(dir);
3500	3666	unsigned tid;
	3667	+ struct proc_fs_info *fs_info;
3501	3668	struct pid_namespace *ns;
3502	3669	struct dentry *result = ERR_PTR(-ENOENT);
3503	3670
..	..	@@ -3508,7 +3675,8 @@
3508	3675	if (tid == ~0U)
3509	3676	goto out;
3510	3677
3511		- ns = dentry->d_sb->s_fs_info;
	3678	+ fs_info = proc_sb_info(dentry->d_sb);
	3679	+ ns = fs_info->pid_ns;
3512	3680	rcu_read_lock();
3513	3681	task = find_task_by_pid_ns(tid, ns);
3514	3682	if (task)
..	..	@@ -3622,7 +3790,7 @@
3622	3790	/* f_version caches the tgid value that the last readdir call couldn't
3623	3791	* return. lseek aka telldir automagically resets f_version to 0.
3624	3792	*/
3625		- ns = proc_pid_ns(inode);
	3793	+ ns = proc_pid_ns(inode->i_sb);
3626	3794	tid = (int)file->f_version;
3627	3795	file->f_version = 0;
3628	3796	for (task = first_tid(proc_pid(inode), tid, ctx->pos - 2, ns);