Attachment 862952 Details for Bug 1062669 – Whitelist symbols for rhel7 -- ready for review.

Whitelist symbols for rhel7 -- ready for review.

Post (text/plain), 27.66 KB, created by George Beshers on 2014-02-13 19:17:58 UTC

(hide)

Description:

Filename:

MIME Type:

Creator: George Beshers

Created: 2014-02-13 19:17:58 UTC

Size: 27.66 KB

patch

obsolete

>
>Overview
>========
>
>First, all the symbols requested here are actively being used
>by modules that are shipping with rhel6 and compile and work
>against the 3.10.0-79 kernel; working on snap 6.
>
>I have tentatively divided the symbols we are requesting into
>two classes:
>    a) those that provide key functionality
>    b) those that are very low risk, e.g., symbols from lib/.
>
>In the case of b) symbols, yes we could duplicate the code of
>snprintf(), strncpy(), etc. but these have been stable a long
>time and the chance of them changing upstream is small.
>Duplication would simply lead to pointless code bloat.
>
>=====================
>
>React is SGI's real time product; it isolates some processors
>from system overhead so that response times are highly reliable.
>
>frs.ko
>------
>The Frame Rate Scheduler (frs.ko) is use by React customers to
>schedule threads at precise intervals; it is absolutely critical
>to our React product.  Key points are:
>
>   A) Uses kthreads for dispatching and other tasks.
>   B) Has timers on all nodes (NUMA)
>   C) Significant interaction with the scheduler.
>
>kbar.ko
>-------
>The Kernel Barrier (kbar.ko) provides for the fast wakeup of
>many blocked user threads.
>
>uli.ko
>------
>The User Level Interrupts (uli.ko) provide an easy to use
>callback driver for user thread interrupt handling.
>
>usercaps.ko
>-----------
>Provides capabilities to specified users without requiring
>root access.  A major React customer considers this to be
>essential.
>
>=== These are not directly connected to React
>
>extint.ko & ioc4_extint.ko
>--------------------------
>The IOC4 is a PCI device that due to historical baggage long
>before it was supported in Linux has a rather unfortunate
>design implementing multiple functionalities (IDE interface,
>RS-482/232 serial ports, a PS2 keyboard/mouse controller, and
>an real-time timer/interrupt function) all under a single PCI
>device/function.
>
>The IOC4 has a master driver and sub-driver structure for
>different functionality; the master driver owns the MMIO
>address range at which the IOC4 chip's register reside.
>
>No one but SGI is likely to touch this code.
>
>hwperf.ko
>---------
>Creates a dynamic device named "/dev/uv_hwperf" that supports an ioctl
>interface to call down into BIOS to read/write memory mapped registers,
>e.g. for performance monitoring.  The "uv_hwperf" device is registered
>only after the sysfs file is first opened, i.e. only if/when it's needed.
>
>The /proc/sgi_uv/topology file provides the node locations, etc.
>
>This API is used by SGI Performance Co-Pilot and other
>tools, see http://oss.sgi.com/projects/pcp
>
>superpages.ko
>-------------
>The superpages module allows users access to large chunks of memory that
>are otherwise unknown to the kernel. Such memory is defined to the BIOS
>as reserved and passed to the superpages module as an ACPI device. This
>memory may be mapped into the user's address space at an address above
>the processor-addressable maximum, and accessed with SGI's GRU memory engine.
>
>xvma.ko
>-------
>The xvma module provides an "extended" vma, above the virtual address range
>of the processors.  Such addresses spaces are needed for superpages and
>xpmem attachments (for process memory-to-memory intercommunication) that
>will be accessed with SGI's GRU memory engine.
>It also supports an "extended" mm struct to head the list of xvma's.
>
>numatools.ko
>------------
>The numatools module primarily provides a user with the ability to do
>very specific placement of a process on cpu's and memory. The user
>accesses the module via the dplace command.  It also provides a user
>a detailed look at process placement, via the dlook command.
>
>perfsock.ko
>-----------
>
>The perfsock kernel module is part of SGI's PerfSocket product.
>PerfSocket intercepts socket communication within large SSIs and
>routes it through user space shared memory. In some cases this
>drastically improves communication performance. The perfsock
>kernel module enables applications to still use
>   poll()
>   select()
>   etc
>even though data is coming through user space shared memory. It
>intercepts kernel socket code calls to check if a socket is
>readable or writeable and adds information about user space buffers.
>It also wakes up threads waiting on an intercepted socket when
>an appropriate user space buffer change has occured.
>
>gru.ko
>------
>The GRU is specialized SGI UV hardware for copying memory through
>the UV interconnect with reduced overhead on the CPUs.  It is tightly
>integrated with the memory system, in particular the MMU.
>
>
>====================================================================
>
>Symbol requests for all the above modules have been merged
>as there were a lot of duplicates.  If a file name is after
>the hash marks that is where the EXPORT_SYMBOL (or variant)
>appears.
>
>
>##########  arch/x86/kernel/apic/apic.c
>(x86_cpu_to_apicid)
>
>Used by the gru to concert a CPU number to thread0 of
>a hyperthread core.  This does assume the low apicid
>bit is for HT.
>
>The React module also uses apicid to send IPI's through
>the UV hub chip.
>
>(apic)
>
>+1 on whitelisting this, we do need it to be external
>because some diagnostics use apic_read and apic_write.
>
>########## arch/x86/kernel/apic/x2apic_uv_x.c
>(__uv_hub_info)
>(sn_rtc_cycles_per_second)
>(is_uv_system)
>(uv_blade_info)
>(uv_cpu_to_blade)
>(uv_node_to_blade)
>(uv_possible_blades)
>
>These are all UV specific symbols asking to whitelist
>(graylist?) as its unlikely anyone else will change
>them; we would only do so to fix a serious bug.
>
>##########  arch/x86/kernel/cpu/common.c
>(current_task)
>
>Used in get_current() which is then used to define "current"
>which is used to get per-task data (pid, tgid, comm, etc.).
>
>(kernel_stack)
>
>Used indirectly through the macro DEFINE_PER_CPU()
>since we frequently need per cpu data.
>
>##########  arch/x86/kernel/paravirt.c
>(pv_irq_ops)
>(pv_mmu_ops)
>(pv_cpu_ops)
>(paravirt_ticketlocks_enabled)
>(pv_lock_ops)
>
>These symbols are required so that SGI modules play
>nice with paravirt in the kernel; yes we are trying
>to make guest OS more Numa aware.
>
>
>########## arch/x86/kernel/setup.c
>(boot_cpu_data)
>
>This struct is used by sync_core() which is
>defined in arch/x86/include/asm/processor.h;
>sync_core() is needed to guarantee data consistency.
>
>It is also used to get the number of physical
>address bits available. and the pgprot_noncached()
>macro in <asm/pgtable.h>.
>
>########## arch/x86/kernel/setup_percpu.c
>(cpu_number)
>
>This is used by raw_smp_processor_id() macro declared in
>arch/x86/include/asm/smp.h; raw_smp_processor_id() is called
>directly to avoid the debug info generated by smp_processor_id()
>should CONFIG_DEBUG_PREEMPT be set and the thread not be pinned
>to this CPU.
>
>(this_cpu_off)
>
>Used by PER_CPU() macro which is required to access per_cpu
>data.
>
>########## arch/x86/kernel/smpboot.c
>(cpu_info)
>
>Used by hwperf in preparing results, particularly
>important if a UV system contains a mixture of cpus
>in different blades.
>
>(cpu_sibling_map)
>
>This is used by the Gru to work around cases where
>the IRQs on CPU0 are exhausted by the DMAR.  DMAR
>assignments happen very early during boot before
>other CPUs have been started.
>
>######### arch/x86/kernel/tsc.c
>(cpu_khz)
>
>This read_mostly value is used by hwperf when
>cpufreq_quick_get() returns 0.
>
>(tsc_khz)
>
>This are read_mostly values is used by the GRU to compute
>the GRU_OPERATION_TIMEOUT for detecting hung instructions.
>
>########## arch/x86/kernel/x8664_ksyms_64.c
>(_copy_to_user)
>(__fentry__)
>(__get_user_2)
>(phys_base)
>(__put_user_2)
>(__put_user_4)
>(__put_user_8)
>
>These are all used for moving data to-from user space.
>Usage is coupled with system calls.
>
>########## arch/x86/lib/usercopy_32.c
>(_copy_from_user)
>
>This is also used for moving data from user space; most
>of the time this is data pointed to by a system call parameter.
>
>########## arch/x86/mm/ioremap.c
>(ioremap_nocache)
>(iounmap)
>
>These are used for IOC4 needing to own the MMIO memory range
>for the registers the IOC4 chip implements.
>
>########## arch/x86/mm/numa.c
>(node_data)
>(__node_distance)
>(node_to_cpumask_map)
>
>These are standard for working with NUMA hardware like UV,
>it is important for performance to know the topology and
>latency information.
>
>########## arch/x86/um/delay.c
>(__const_udelay)
>
>This is used by the Frame Rate Scheduler to schedule
>threads at precise intervals.
>
>########## arch/x86/platform/uv/bios_uv.c
>(sn_coherency_id)
>(sn_partition_id)
>(sn_region_size)
>(uv_bios_call)
>(uv_type)
>(uv_setup_irq)
>(uv_teardown_irq)
>
>These are all UV specific symbols we are asking to whitelist
>(graylist?) as its unlikely anyone else will change
>them; we would only do so to fix a serious bug.
>
>########## drivers/base/class.c
>(__class_register)
>(class_unregister)
>
>The extint.ko and ioc4_extint.ko modules used these
>routines (the first indirectly via the class_register macro)
>to creat a class to which devices are added.
>
>########## drivers/base/core.c
>(dev_err)
>(_dev_info)
>(dev_warn)
>
>These are just conventient forms of printk(), if alternatives
>are considered preferable that isn't a big deal.
>
>(device_register)
>(device_unregister)
>
>These are used with low level character devices created
>byt the extint.k and ioc4_extint.ko modules.
>
>(device_create_file)
>(device_remove_file)
>
>These are used to handle the attributes of the device
>registered by the above symbols.
>
>(dev_set_name)
>
>Set this device name in the class; function has been unchanged
>since rhel6 and in Linus' current tree.
>
>########## drivers/char/misc.c
>(misc_deregister)
>(misc_register)
>
>Most of our modules create a misc character device and
>use these functions; these functions declarations have
>not changed from rhel6 to Linus' tree.
>
>########## drivers/cpufreq/cpufreq.c
>(cpufreq_quick_get)
>
>Used by hwperf to get the frequency each cpu is running at; this
>is used mostly for recording pertainent machine configuration
>details with the performance results.
>
>########## drivers/misc/ioc4.c
>(ioc4_register_submodule)
>(ioc4_unregister_submodule)
>
>The ioc4 is legacy SGI hardware which we still need to support.
>These symbols are required to support some legacy oddball functionality.
>
>##########  drivers/misc/sgi-xp/xp_main.c
>(xpc_connect)
>(xpc_disconnect)
>(xpc_interface)
>(xp_expand_memprotect)
>(xp_partition_id)
>(xp_restrict_memprotect)
>
>These symbols are all sgi-xp symbols; SGI is the only one
>likely to change them and we would only consider doing so
>to fix a serious error.
>
>##########  drivers/pnp/driver.c
>
>(pnp_register_driver)
>(pnp_unregister_driver)
>(pnp_get_resource)
>
>The large chuncks of memory that are reserved to be superpages
>are defined as reserved to the BIOS and passed to the the superpages
>module as an ACPI device, "superpages".   These symbols are
>required to handle that device.
>
>
>########## fs/char_dev.c
>(alloc_chrdev_region)
>(unregister_chrdev_region)
>
>Used extint.ko and ioc4_extint.ko for managing external interupt
>device numbers.
>
>(cdev_add)
>(cdev_del)
>(cdev_init)
>
>Used by extint.ko and ioc4_extint.ko manage cdev for character device.
>
>########## fs/debugfs/file.c
>(debugfs_create_u32)
>
>The gru exposes some table entries and table drops through debugfs.
>
>########## fs/debugfs/inode.c
>(debugfs_create_dir)
>(debugfs_create_file)
>(debugfs_remove)
>
>The gru exposes some table entries and table drops through debugfs.
>
>########## fs/file.c
>(fget)
>
>Used by perfsock.ko to get the file descriptor give the socket number.
>
>########## fs/file_table.c
>(fput)
>
>Used by perfsock.ko; partnered with fget() above.
>
>########## fs/libfs.c 
>(simple_read_from_buffer)
>
>Used by extint.ko to implement the file_operations.read().
>
>########## fs/proc/generic.c
>(PDE_DATA)
>(proc_create_data)
>(proc_mkdir)
>(proc_remove)
>(proc_set_user)
>(remove_proc_entry)
>
>The modules xpmem, numatools, hwperf, gru all expose information
>in the /proc pseudo file system.
>
>
>########## fs/read_write.c
>(noop_llseek)
>
>Used by the gru.ko as the file_operations.llseek().
>
>##########  fs/seq_file.c 
>(seq_lseek)
>(seq_open)
>(seq_printf)
>(seq_putc)
>(seq_puts)
>(seq_read)
>(seq_release)
>(single_open)
>(single_release)
>
>Used by the gru to implement
>cch_status  debug_options  gru_status  mcs_statistics  statistics 
>under /proc/sgi_uv/gru.
>
>Used by hwperf to implement
>bios_version  nilink_rerouting  system_serial_number hub_revision
>under /proc/sgi_uv.
>
>########### init/init_task.c
>init_task
>
>This symbol is used by the do_each_thread() macro which
>in turn is used to scan the process list for those that
>react is interested in, frs.ko.
>
>
>########## kernel/capability.c
>(capable)
>
>Used by the gru.ko to test CAP_SYS_ADMIN and by
>xpmem.ko to test CAP_IPC_OWNER.
>
>########## kernel/cpu.c
>(cpu_active_mask)
>(cpu_online_mask)
>(cpu_possible_mask)
>(cpu_bit_bitmap)
>
>Most of SGI modules use cpu_online_mask() and the
>others are all used to play nice with cpu hotplug
>functionality.
>
>########## kernel/cred.c
>(abort_creds)
>(commit_creds)
>(prepare_creds)
>
>usercaps.ko - Provides capabilities to specified users without requiring
>root access.  These function as used to provided the necessary capabilities.
>
>########## kernel/events/core.c
>(perf_tp_event)
>
>xpmem.ko provides tracing support, symbol is used via TRACE_EVENT.
>
>########## 	kernel/exit.c
>(do_exit)
>
>Called from xpmem.ko as part of mmu_notifier_ops.release()
>which (I think) is only happening on thread termination.
>
>##########  kernel/fork.c
>(get_task_mm)
>
>Superpages.ko and xpmem.ko getting a pointer to the mm_struct
>for a task and incrementing the count.
>
>(__mmdrop)
>
>Called via mmdrop() after the mm has been passed to mmu_notifier_unregister().
>
>(mmput)
>
>Called by xpmem, superpages, and numatools at then end
>of a cleanup sequence.
>
>##########  kernel/groups.c
>(in_group_p)
>
>Used by xpmem.ko to check permission bits for IPC.
>
>########## kernel/irq/manage.c
>(free_irq)
>(request_threaded_irq)
>
>Called via request_irq() because gru.ko, hwperf.ko, and ioc4_extint.ko
>all need to handle interrupts.  The calls to free_irq() are paired.
>
>########## kernel/kmod.c
>(call_usermodehelper)
>
>This is used by React to set the dispatcher's priority to 10 so
>that it is always run when scheduled.
>
>########## kernel/kthread.c
>(kthread_create_on_node)
>
>Used by frs.ko (React), superpages.ko, and xpmem.ko via
>kthread_create() or kthread_run().
>
>For frs.ko the thread is the per_cpu dispatcher.
>For superpages.ko the thread is responsible for zeroing memory
>and other initialization.
>For xpmem.ko has three kinds of threads
>   a) tear down when disassociating a region of memory from
>   from a partition.
>   b) cleaning up after the mmu_notifier.release(), i.e., the
>   thread is started from mmu_notifier.release().
>   c) Helper thread to allow mmu_notifier_invalidate_page() to escape the
>   spinlock context; one particular case is when the remote partition
>   has abruptly powered down (or panic...).
>
>(kthread_bind)
>(kthread_should_stop)
>
>These are used by frs.ko -- the bind is to a specific cpu.
>
>########## kernel/module.c
>(__module_get)
>
>Used by numatools to make sure module doesn't get unloaded
>from a cpu during a dplace command on that cpu, module_put()
>happens at the end of the function.
>
>(module_put)
>(try_module_get)
>
>Used in pairs to avoid a module being unloaded with a registered
>callback pending.
>
>########## kernel/mutex.c
>(__mutex_init)
>(mutex_lock_interruptible)
>(mutex_lock)
>(mutex_trylock)
>(mutex_unlock)
>
>Standard mutex interface.  The mutex_lock_interruptible() is used
>from xpmem.ko when detaching an xpmem address segment.  The others
>are widely used.
>
>########## kernel/panic.c
>(panic)
>(__stack_chk_fail)
>
>Happens, even in SGI code :).
>
>##########	kernel/params.c
>(param_array_ops)
>(param_ops_charp)
>(param_ops_int)
>(param_ops_ulong)
>
>########## kernel/pid.c
>pid_task
>(find_pid_ns)
>
>########## kernel/printk.c
>(printk)
>
>Required so that console log doesn't get jumbled.
>
>########## kernel/rcutree.c
>(synchronize_sched)
>
>########## kernel/resource.c
>(iomem_resource)
>
>(__release_region)
>(__request_region)
>
>These are called by request_mem_region() and
>release_mem_region() macros which are used by
>basically every PCI-driver;  SGI's IOC4 is
>no exception.
>
>########## kernel/rwsem.c
>(downgrade_write)
>(down_read)
>(down_read_trylock)
>(down_write)
>(down_write_trylock)
>(up_read)
>(up_write)
>
>Standard interface to read/write semaphores.
>Note: the upstream gru.ko uses this.
>
>########## kernel/sched/core.c
>(complete_all)
>(complete)
>(wait_for_completion)
>
>The gru.ko, hwperf.ko, and xpmem.ko all use completions
>to wakeup threads.
>
>(schedule)
>
>Most of the modules need to use schedule to block threads.
>
>(default_wake_function)
>(__wake_up)
>(wake_up_process)
>
>Threads need to get restarted, __wake_up is usually called
>via wake_up() macro, but sometimes wak_up_interruptible().
>
>(set_user_nice)
>
>This is used to set a cleanup thread priority to -10;
>there can be a long delay in xpmem if a remote partition
>is abruptly powered down (or panics...)
>
>(set_cpus_allowed_ptr)
>
>Used in multiple modules to change a task's CPU affinity.
>
>########## kernel/semaphore.c
>(down_interruptible)
>(down)
>(down_trylock)
>(up)
>
>Standard semaphore interface.
>
>########## kernel/signal.c
>(recalc_sigpending)
>
>xpmem.ko uses this to block and unblock non-fatal signals,
>e.g., when calling mmu_notifier_register().
>
>(send_sig)
>
>frs.ko sends signals to threads in particular from timer
>interrups.
>
>########## kernel/smp.c
>(nr_cpu_ids)
>
>Standard query on system size.
>
>########## kernel/softirq.c
>(tasklet_init)
>(__tasklet_schedule)
>
>frs.ko uses tasklet to delay work until irq's are re-enabled.
>
>########## kernel/spinlock.c
>(_raw_read_lock_irqsave)
>(_raw_read_lock)
>(_raw_read_unlock_irqrestore)
>(_raw_spin_lock_irq)
>(_raw_spin_lock_irqsave)
>(_raw_spin_lock)
>(_raw_spin_trylock)
>(_raw_spin_unlock_irqrestore)
>(_raw_spin_unlock)
>(_raw_write_lock_irqsave)
>(_raw_write_lock)
>(_raw_write_trylock)
>(_raw_write_unlock_irqrestore)
>
>Yes we use spinlocks, surpised these were not whitelisted.
>
>########## kernel/time.c
>(msecs_to_jiffies)
>
>Standard conversion used to avoid complications if HZ changes.
>
>########## kernel/time/jiffies.c
>(jiffies)
>
>Yes we do need jiffies, usually timeout related.
>
>########## kernel/timer.c
>(init_timer_key)
>(msleep_interruptible)
>(msleep)
>(schedule_timeout)
>(usleep_range)
>
>Schedule delays, often associated with timeouts.
>
>########## kernel/time/timekeeping.c
>(getnstimeofday)
>
>Antiquated time support by the IOC4.
>
>########## kernel/trace/ring_buffer.c
>(ring_buffer_event_data)
>
>Implicitly used in xpmem.ko by the tracing code.
>
>########## kernel/trace/trace.c
>(filter_current_check_discard)
>(trace_buffer_unlock_commit)
>(trace_event_buffer_lock_reserve)
>
>xpmem.ko used implicitly via DECLARE_EVENT_CLASS.
>
>########## kernel/trace/trace_event_perf.c
>(perf_trace_buf_prepare)
>
>xpmem.ko used implicitly via DECLARE_EVENT_CLASS.
>
>########## kernel/trace/trace_events.c
>(event_storage)
>(event_storage_mutex)
>(ftrace_event_reg)
>(trace_define_field)
>(trace_event_raw_init)
>
>xpmem.ko used implicitly via DECLARE_EVENT_CLASS.
>
>########## kernel/trace/trace_output.c
>(ftrace_raw_output_prep)
>(trace_seq_printf)
>
>xpmem.ko used implicitly via DECLARE_EVENT_CLASS.
>
>########## kernel/up.c
>(smp_call_function_single)
>
>This is used in React (frs.ko, kbar.ko, uli.ko) when
>something needs to be run on a specific cpu and time
>is critical.
>
>########## kernel/wait.c
>(add_wait_queue_exclusive)
>
>Used by frs.ko for the implementation of sleeping
>barriers for kernel inter-process synchronization.
>
>(autoremove_wake_function)
>(finish_wait)
>
>Both are used indirectly by the wait_event*() macros,
>autoremove_wake_function by the DEFINE_WAIT macro.
>
>(__init_waitqueue_head)
>
>Used viar init_waitqueue_head() in every module where
>waitqueues are used: extint.ko, frs.ko, gru.ko, hwperf.ko,
>kbar.ko, superpages.ko, xpmem.ko
>
>(prepare_to_wait)
>
>Primarily by xpmem.ko via the wait_event*() macros.
>
>(remove_wait_queue)
>
>Cleanup required if using wait_queues.
>
>########## kernel/workqueue.c
>(cancel_delayed_work_sync)
>
>Used by the gru to cleanup state associated with a gru
>specific thread.
>
>(delayed_work_timer_fn)
>
>Used by the INIT_DELAYED_WORK in the gru.ko and xpmem.ko.
>In both cases either work is being moved
>
>(queue_delayed_work_on)
>
>Used via schedule_delayed_work_on().
>
>(queue_work_on)
>
>Used via schedule_work().
>
>(system_wq)
>
>Used via schedule_delayed_work_on() macro.
>
>
>########## lib/bitmap.c
>(__bitmap_and)
>(__bitmap_empty)
>(__bitmap_equal)
>(__bitmap_intersects)
>(__bitmap_subset)
>(__bitmap_weight)
>
>The above functions are all in lib/bitmap.c
>and have not changed since rhel6 and are unchanged
>upstream.  Very low risk of whitelisting.
>
>########## lib/cpumask.c
>(__first_cpu)
>(__next_cpu)
>(__next_cpu_nr)
>
>The above functions are all in lib/cpumask.c
>and have not changed since rhel6 and are unchanged
>upstream.  Very low risk of whitelisting.
>
>########## lib/ctype.c
>(_ctype)
>
>This is a struct in lib/ctype.c.
>Between rhel6 and rhel7 a 'const' was added;
>no change from rhel7 and Linus' kernel.
>Very low risk of whitelisting.
>
>########## lib/find_next_bit.c
>(find_first_bit)
>(find_first_zero_bit)
>(find_next_bit)
>
>These functions are in lib/find_next_bit.c
>and are unchanged rhel6 -> Linus'.
>Very low risk of whitelisting.
>
>########## lib/hweight.c
>(__sw_hweight32)
>(__sw_hweight64)
>
>These functions are in lib/hweight.c, the __sw
>was added after rhel6; rhel7 to Linus' is unchanged.
>Very low risk of whitelisting.
>
>########## lib/kobject.c
>(kobject_put)
>(kobject_set_name)
>
>These functions are in lib/kobject.c and are
>unchanged rhel6 -> Linus'.
>Very low risk of whitelisting.
>
>########## lib/kstrtox.c
>(kstrtoull)
>
>This is in lib/kstrtox.c the only change between
>rhel7 and upstream is a minor cleanup of a redundant
>overflow line.  See
>
>commit ae2924a2bdc5255745e68f2b9206404ddadfc5bf
>Author: Felipe Contreras <felipe.contreras@gmail.com>
>Date:   Thu Jan 23 15:54:34 2014 -0800
>
>Low risk of whitelisting.
>
>########## lib/list_debug.c
>(__list_add)
>(__list_del_entry)
>(list_del)
>
>These are in lib/list_debug.c; the file is unchanged
>between rhel7 and upstream.  Note __list_del_entry is
>new in rhel7 and the implementation of the others has
>changed to add warnings, but there declaration is the
>same as in rhel6.
>
>Low risk of whitelisting.
>
>##########  lib/rbtree.c
>(rb_erase)
>(rb_first)
>(rb_insert_color)
>(rb_next)
>
>These are in lib/rbtree.c; the implementation
>changed between rhel6 and rhel7 (not the declarations),
>but rhel7 to upstream they are unchanged.
>
>Low risk of whitelisting.
>
>########## lib/rwsem.c
>(__init_rwsem)
>
>This is in lib/rwsem.c but has been moved to
>kernel/locking upstream.  The declaration is
>unchanged.
>
>Low risk of whitelisting.
>
>##########  lib/sort.c
>(sort)
>
>This is in lib/sort.c which is unchanged rhel6 -> Linus'.
>Very low risk of whitelisting.
>
>##########  lib/string.c
>(memcmp)
>(memcpy)
>(memset)
>(strcmp)
>(strcpy)
>(strlen)
>(strncmp)
>(strncpy)
>(strstr)
>
>These are in lib/string.c; there are a few cleanup changes
>rhel6 -> rhel7, but the files are identical rhel7 to upstream.
>Very low risk of whitelisting.
>
>########## lib/strncpy_from_user.c
>(strncpy_from_user)
>
>The file lib/strncpy_from_user.c is new in rhel7, but unchanged
>between rhel7 and upstream.
>
>########## lib/vsprintf.c
>(snprintf)
>(sprintf)
>(sscanf)
>(vsprintf)
>
>These functions are in lib/vsprintf.c.
>They are unchanged rhel7 to Linus' and
>the declarations have been stable since rhel6.
>
>Yes we could switch to the 'n' versions.
>
>Low risk of whitelisting.
>
>
>########## mm/memory.c
>(get_user_pages)
>
>The gru.ko module uses this to convert vaddr to a physical address
>that the gru can handle.
>The xpmem.ko module uses this to test if an address is backed
>by a huge page.
>
>(remap_pfn_range)
>
>This is used by the gru when vm_operations_struct.fault() is
>called.
>
>(vm_insert_pfn)
>
>The xpmem.ko module uses vm_insert_pfn() to keep the page
>tables consistent for pages that are share across partitions.
>NOTE: two or more kernels involved.
>
>(zap_vma_ptes)
>
>Needed for the gru and xpmem modules to cleanup after
>themselves.
>
>########## mm/mempolicy.c
>(alloc_pages_current)
>
>Superpages only uses this in test mode when the module is using memory
>that is know to the kernel.
>
>########## mm/mmu_context.c
>(unuse_mm)
>(use_mm)
>
>Inevitably the gru can get into exception situations, when that
>happens and it can aquire the mmap_sem and ts_ctxlock locks then
>use_mm() and unuse_mm() are used the kernel responsible for
>cleanup.
>
>########## mm/mmu_notifier.c
>(__mmu_notifier_register)
>(mmu_notifier_register)
>(mmu_notifier_unregister)
>
>SGI GRU (part of each Hub) uses the mmu_notifier mechanism
>to manage pages that are being read/writen by the GRU hardware.
>
>########## mm/nommu.c
>(find_vma)
>(vm_munmap)
>
>The module xvma.ko implements an extended vma (xvma), and is logically
>attached to a vm_area_struct when the area is being addressed at a
>virtual address range above that of the processors. find_vma() is
>used to locate vma's during the cloning of xmm's and xvma's during
>a fork operation.
>
>The gru.ko, superpages.ko, and xpmem.ko modules are all working
>with mapping in and unmapping a range of memory as a vma in user
>space; they need to locate existing vmas for a number of reasons.
>
>
>########## mm/page_alloc.c
>(numa_node)
>
>Superpages uses numa_node_id() is used to map a superpage to the nearest node.
>Numatools uses cpu_to_node() is used relate cpu to node memory.
>
>(__alloc_pages_nodemask)
>
>Gru uses alloc_pages_node() to allocate memory in a NUMA thoughtful
>way.
>
>(__free_pages)
>
>Superpages only uses this in test mode when the module is using memory
>that is known to the kernel.
>
>(free_pages)
>
>The gru, numatools, superpages all uses this release pages.
>
>(__get_free_pages)
>
>This is only used by numatools.ko, it appears that page alignment
>might be the reason; the page is returned via free_page() before
>the end of the function.
>
>(get_zeroed_page)
>
>Called indirectly from pmd_alloc_one() and pud_alloc_one()
>by superpages for middle and upper directories respectively,
>pgd_populate() is called with the results.  NOTE: I'm
>not sure why pmd_alloc() and pud_alloc() were not used.
>
>(node_states)
>
>Multiple uses by multiple modules, always used indirectly
>via for_each_online_node(). Examples: to allocate timers
>on all nodes, to find an irq (by hwperf), determine the
>size of each online node's level3 page tables.
>
>########## mm/percpu.c
>(__per_cpu_offset)
>
>The per_cpu macro uses this and several of our modules
>declare per_cpu data, e.g., frs has per cpu timers information
>and kbar.ko maintains active status per_cpu.
>
>########## mm/slab_common.c
>(kmalloc_caches)
>
>Called by kmalloc_slab() (from kmalloc()) and kmalloc_node().
>
>(kmem_cache_create)
>(kmem_cache_destroy)
>
>These are called by xpmem.ko as it co-ordinates memory usage
>across partitions.
>
>########## mm/slub.c
>(__kmalloc)
>(kmem_cache_alloc_node_trace)
>(kmem_cache_alloc_trace)
>
>Thes are all Called from kmalloc() which is the standard way
>to allocate memory.
>
>(kmalloc_order_trace)
>
>Called from kmalloc_large() macro which is in turned called
>from kmalloc().
>
>########## mm/sparse.c
>(mem_section)
>
>Array of structures directly or indirectly used by present_section_nr(),
>valid_section_nr(), pfn_present(), etc.
>
>########## mm/swap.c
>(__get_page_tail)
>
>Called indirectly by get_page()
>
>(put_page)
>
>Usually called via page_cache_release(), just releaseing pages.
>
>########## mm/util.c
>(vm_mmap)
>
>Superpages and xpmem mapping memory.
>
>(kfree)
>
>Reverse of kmalloc().
>
>(kmem_cache_alloc)
>(kmem_cache_free)
>
>These are used by xpmem to manage cross partition (2+ kernels)
>memory access.
>
>########## mm/vmalloc.c
>(vfree)	
>(vmalloc)
>
>Widely used memory allocation routines.
>
>########## net/ipv4/af_inet.c 
>(inet_release)
>
>Called during cleanup when a ipv4 socket is closed,
>the inet_stream_ops for the socket have been substituted
>to call a perfsocket routine which then calls the
>standard release.
>
>(inet_stream_ops)
>Used to initialize perfsocket' proto_ops structure
>for the socket.
>
>########## net/ipv4/tcp.c
>(tcp_poll)
>
>Called by perfsock.ko tracker_poll() which has been
>substituted into the inet_stream_ops for a socket.
>
>########## net/ipv6/af_inet6.c
>(inet6_release)
>
>Called during cleanup when a ipv6 socket is closed,
>the inet_stream_ops for the socket have been substituted
>to call a perfsocket routine which then calls the
>standard release.
>
>########## net/socket.c
>(sockfd_lookup)
>
>Used by perfsock.ko to capture a specific socket.
>
>(sock_wake_async)
>
>Used by perfsock.ko via sk_wake_async() to pass a
>SOCK_WAKE_IO

Actions: View

Attachments on bug 1062669: 860715 | 861221 | 861222 | 861371 | 862952 | 871236