Merge tag 'docs-5.1' of git://git.lwn.net/linux
authorLinus Torvalds <torvalds@linux-foundation.org>
Sat, 9 Mar 2019 17:56:17 +0000 (09:56 -0800)
committerLinus Torvalds <torvalds@linux-foundation.org>
Sat, 9 Mar 2019 17:56:17 +0000 (09:56 -0800)
Pull documentation updates from Jonathan Corbet:
 "A fairly routine cycle for docs - lots of typo fixes, some new
  documents, and more translations. There's also some LICENSES
  adjustments from Thomas"

* tag 'docs-5.1' of git://git.lwn.net/linux: (74 commits)
  docs: Bring some order to filesystem documentation
  Documentation/locking/lockdep: Drop last two chars of sample states
  doc: rcu: Suspicious RCU usage is a warning
  docs: driver-api: iio: fix errors in documentation
  Documentation/process/howto: Update for 4.x -> 5.x versioning
  docs: Explicitly state that the 'Fixes:' tag shouldn't split lines
  doc: security: Add kern-doc for lsm_hooks.h
  doc: sctp: Merge and clean up rst files
  Docs: Correct /proc/stat path
  scripts/spdxcheck.py: fix C++ comment style detection
  doc: fix typos in license-rules.rst
  Documentation: fix admin-guide/README.rst minimum gcc version requirement
  doc: process: complete removal of info about -git patches
  doc: translations: sync translations 'remove info about -git patches'
  perf-security: wrap paragraphs on 72 columns
  perf-security: elaborate on perf_events/Perf privileged users
  perf-security: document collected perf_events/Perf data categories
  perf-security: document perf_events/Perf resource control
  sysfs.txt: add note on available attribute macros
  docs: kernel-doc: typo "if ... if" -> "if ... is"
  ...

1  2 
Documentation/admin-guide/kernel-parameters.txt
Documentation/cgroup-v1/memory.txt
Documentation/filesystems/sysfs.txt
Documentation/networking/index.rst
Documentation/sysctl/kernel.txt
include/linux/module.h
include/linux/skbuff.h
scripts/checkpatch.pl
security/selinux/hooks.c

index 42379633801f4741a1af5a03c1153b1230d948eb,b251494d1b6617fbbf9eea8e27b6e11d9600694f..49f2acc5eecee20df0836205f62ad052eaa87aba
                        possible to determine what the correct size should be.
                        This option provides an override for these situations.
  
 +      carrier_timeout=
 +                      [NET] Specifies amount of time (in seconds) that
 +                      the kernel should wait for a network carrier. By default
 +                      it waits 120 seconds.
 +
        ca_keys=        [KEYS] This parameter identifies a specific key(s) on
                        the system trusted keyring to be used for certificate
                        trust validation.
                        The filter can be disabled or changed to another
                        driver later using sysfs.
  
 +      driver_async_probe=  [KNL]
 +                      List of driver names to be probed asynchronously.
 +                      Format: <driver_name1>,<driver_name2>...
 +
        drm.edid_firmware=[<connector>:]<file>[,[<connector>:]<file>]
                        Broken monitors, graphic adapters, KVMs and EDIDless
                        panels may send no or incorrect EDID data sets.
                        specified address. The serial port must already be
                        setup and configured. Options are not yet supported.
  
 +              efifb,[options]
 +                      Start an early, unaccelerated console on the EFI
 +                      memory mapped framebuffer (if available). On cache
 +                      coherent non-x86 systems that use system memory for
 +                      the framebuffer, pass the 'ram' option so that it is
 +                      mapped with the correct attributes.
 +
        earlyprintk=    [X86,SH,ARM,M68k,S390]
                        earlyprintk=vga
 -                      earlyprintk=efi
                        earlyprintk=sclp
                        earlyprintk=xen
                        earlyprintk=serial[,ttySn[,baudrate]]
                        arch/x86/kernel/cpu/cpufreq/elanfreq.c.
  
        elevator=       [IOSCHED]
-                       Format: {"cfq" | "deadline" | "noop"}
-                       See Documentation/block/cfq-iosched.txt and
-                       Documentation/block/deadline-iosched.txt for details.
+                       Format: { "mq-deadline" | "kyber" | "bfq" }
+                       See Documentation/block/deadline-iosched.txt,
+                       Documentation/block/kyber-iosched.txt and
+                       Documentation/block/bfq-iosched.txt for details.
  
        elfcorehdr=[size[KMG]@]offset[KMG] [IA64,PPC,SH,X86,S390]
                        Specifies physical address of start of kernel core
                        By default, super page will be supported if Intel IOMMU
                        has the capability. With this option, super page will
                        not be supported.
 -              sm_off [Default Off]
 -                      By default, scalable mode will be supported if the
 +              sm_on [Default Off]
 +                      By default, scalable mode will be disabled even if the
                        hardware advertises that it has support for the scalable
                        mode translation. With this option set, scalable mode
 -                      will not be used even on hardware which claims to support
 -                      it.
 +                      will be used on hardware which claims to support it.
                tboot_noforce [Default Off]
                        Do not force the Intel IOMMU enabled under tboot.
                        By default, tboot will force Intel IOMMU on, which
                        Built with CONFIG_DEBUG_KMEMLEAK_DEFAULT_OFF=y,
                        the default is off.
  
+       kpti=           [ARM64] Control page table isolation of user
+                       and kernel address spaces.
+                       Default: enabled on cores which need mitigation.
+                       0: force disabled
+                       1: force enabled
        kvm.ignore_msrs=[KVM] Ignore guest accesses to unhandled MSRs.
                        Default is 0 (don't ignore, but inject #GP)
  
  
        lsm.debug       [SECURITY] Enable LSM initialization debugging output.
  
 +      lsm=lsm1,...,lsmN
 +                      [SECURITY] Choose order of LSM initialization. This
 +                      overrides CONFIG_LSM, and the "security=" parameter.
 +
        machvec=        [IA-64] Force the use of a particular machine-vector
                        (machvec) in a generic kernel.
                        Example: machvec=hpzx1_swiotlb
                        latencies, which will choose a value aligned
                        with the appropriate hardware boundaries.
  
 -      rcutree.jiffies_till_sched_qs= [KNL]
 -                      Set required age in jiffies for a
 -                      given grace period before RCU starts
 -                      soliciting quiescent-state help from
 -                      rcu_note_context_switch().  If not specified, the
 -                      kernel will calculate a value based on the most
 -                      recent settings of rcutree.jiffies_till_first_fqs
 -                      and rcutree.jiffies_till_next_fqs.
 -                      This calculated value may be viewed in
 -                      rcutree.jiffies_to_sched_qs.  Any attempt to
 -                      set rcutree.jiffies_to_sched_qs will be
 -                      cheerfully overwritten.
 -
        rcutree.jiffies_till_first_fqs= [KNL]
                        Set delay from grace-period initialization to
                        first attempt to force quiescent states.
                        quiescent states.  Units are jiffies, minimum
                        value is one, and maximum value is HZ.
  
 +      rcutree.jiffies_till_sched_qs= [KNL]
 +                      Set required age in jiffies for a
 +                      given grace period before RCU starts
 +                      soliciting quiescent-state help from
 +                      rcu_note_context_switch() and cond_resched().
 +                      If not specified, the kernel will calculate
 +                      a value based on the most recent settings
 +                      of rcutree.jiffies_till_first_fqs
 +                      and rcutree.jiffies_till_next_fqs.
 +                      This calculated value may be viewed in
 +                      rcutree.jiffies_to_sched_qs.  Any attempt to set
 +                      rcutree.jiffies_to_sched_qs will be cheerfully
 +                      overwritten.
 +
        rcutree.kthread_prio=    [KNL,BOOT]
                        Set the SCHED_FIFO priority of the RCU per-CPU
                        kthreads (rcuc/N). This value is also used for
                        This wake_up() will be accompanied by a
                        WARN_ONCE() splat and an ftrace_dump().
  
 +      rcutree.sysrq_rcu= [KNL]
 +                      Commandeer a sysrq key to dump out Tree RCU's
 +                      rcu_node tree with an eye towards determining
 +                      why a new grace period has not yet started.
 +
        rcuperf.gp_async= [KNL]
                        Measure performance of asynchronous
                        grace-period primitives such as call_rcu().
                        Note: increases power consumption, thus should only be
                        enabled if running jitter sensitive (HPC/RT) workloads.
  
 -      security=       [SECURITY] Choose a security module to enable at boot.
 -                      If this boot parameter is not specified, only the first
 -                      security module asking for security registration will be
 -                      loaded. An invalid security module name will be treated
 -                      as if no module has been chosen.
 +      security=       [SECURITY] Choose a legacy "major" security module to
 +                      enable at boot. This has been deprecated by the
 +                      "lsm=" parameter.
  
        selinux=        [SELINUX] Disable or enable SELinux at boot time.
                        Format: { "0" | "1" }
        usbcore.authorized_default=
                        [USB] Default USB device authorization:
                        (default -1 = authorized except for wireless USB,
 -                      0 = not authorized, 1 = authorized)
 +                      0 = not authorized, 1 = authorized, 2 = authorized
 +                      if device connected to internal port)
  
        usbcore.autosuspend=
                        [USB] The autosuspend time delay (in seconds) used
index a347fc9293e56b04a998b0c38316175da590c3d8,8e2cb1dabeb030fcb5e66334904216ef875df6ad..a33cedf85427af730e3dcc6060f07ca00291d88b
@@@ -70,7 -70,7 +70,7 @@@ Brief summary of control files
   memory.soft_limit_in_bytes    # set/show soft limit of memory usage
   memory.stat                   # show various statistics
   memory.use_hierarchy          # set/show hierarchical account enabled
-  memory.force_empty            # trigger forced move charge to parent
+  memory.force_empty            # trigger forced page reclaim
   memory.pressure_level                 # set memory pressure notifications
   memory.swappiness             # set/show swappiness parameter of vmscan
                                 (See sysctl's vm.swappiness)
@@@ -267,11 -267,11 +267,11 @@@ When oom event notifier is registered, 
     Other lock order is following:
     PG_locked.
     mm->page_table_lock
 -       zone_lru_lock
 +       pgdat->lru_lock
          lock_page_cgroup.
    In many cases, just lock_page_cgroup() is called.
    per-zone-per-cgroup LRU (cgroup's private LRU) is just guarded by
 -  zone_lru_lock, it has no lock of its own.
 +  pgdat->lru_lock, it has no lock of its own.
  
  2.7 Kernel Memory Extension (CONFIG_MEMCG_KMEM)
  
@@@ -459,8 -459,9 +459,9 @@@ About use_hierarchy, see Section 6
    the cgroup will be reclaimed and as many pages reclaimed as possible.
  
    The typical use case for this interface is before calling rmdir().
-   Because rmdir() moves all pages to parent, some out-of-use page caches can be
-   moved to the parent. If you want to avoid that, force_empty will be useful.
+   Though rmdir() offlines memcg, but the memcg may still stay there due to
+   charged file caches. Some out-of-use page caches may keep charged until
+   memory pressure happens. If you want to avoid that, force_empty will be useful.
  
    Also, note that when memory.kmem.limit_in_bytes is set the charges due to
    kernel pages will still be seen. This is not considered a failure and the
index 41411b0c60a3b2a6ee14cd5ff8b1590557bd9711,d70c8f112662340e57e01988c266364b8049ad60..5b5311f9358dee0d24979ad8052f68b1417efb89
@@@ -116,6 -116,27 +116,27 @@@ static struct device_attribute dev_attr
        .store = store_foo,
  };
  
+ Note as stated in include/linux/kernel.h "OTHER_WRITABLE?  Generally
+ considered a bad idea." so trying to set a sysfs file writable for
+ everyone will fail reverting to RO mode for "Others".
+ For the common cases sysfs.h provides convenience macros to make
+ defining attributes easier as well as making code more concise and
+ readable. The above case could be shortened to:
+ static struct device_attribute dev_attr_foo = __ATTR_RW(foo);
+ the list of helpers available to define your wrapper function is:
+ __ATTR_RO(name): assumes default name_show and mode 0444
+ __ATTR_WO(name): assumes a name_store only and is restricted to mode
+                  0200 that is root write access only.
+ __ATTR_RO_MODE(name, mode): fore more restrictive RO access currently
+                  only use case is the EFI System Resource Table
+                  (see drivers/firmware/efi/esrt.c)
+ __ATTR_RW(name): assumes default name_show, name_store and setting
+                  mode to 0644.
+ __ATTR_NULL: which sets the name to NULL and is used as end of list
+                  indicator (see: kernel/workqueue.c)
  
  Subsystem-Specific Callbacks
  ~~~~~~~~~~~~~~~~~~~~~~~~~~~~
@@@ -344,9 -365,7 +365,9 @@@ struct bus_attribute 
  
  Declaring:
  
 -BUS_ATTR(_name, _mode, _show, _store)
 +static BUS_ATTR_RW(name);
 +static BUS_ATTR_RO(name);
 +static BUS_ATTR_WO(name);
  
  Creation/Removal:
  
index f0da1b00151477c5c4630164f1f2ced8de7d8694,44a0f1939fcd9ebcceab6ac9273a322be57df729..5449149be496fa8448fa5b74bafe2c5c796cb06d
@@@ -11,31 -11,30 +11,34 @@@ Contents
     batman-adv
     can
     can_ucan_protocol
 -   dpaa2/index
 -   e100
 -   e1000
 -   e1000e
 -   fm10k
 -   igb
 -   igbvf
 -   ixgb
 -   ixgbe
 -   ixgbevf
 -   i40e
 -   iavf
 -   ice
 +   device_drivers/freescale/dpaa2/index
 +   device_drivers/intel/e100
 +   device_drivers/intel/e1000
 +   device_drivers/intel/e1000e
 +   device_drivers/intel/fm10k
 +   device_drivers/intel/igb
 +   device_drivers/intel/igbvf
 +   device_drivers/intel/ixgb
 +   device_drivers/intel/ixgbe
 +   device_drivers/intel/ixgbevf
 +   device_drivers/intel/i40e
 +   device_drivers/intel/iavf
 +   device_drivers/intel/ice
 +   devlink-info-versions
 +   ieee802154
     kapi
     z8530book
     msg_zerocopy
     failover
     net_failover
 +   phy
 +   sfp-phylink
     alias
     bridge
     snmp_counter
+    checksum-offloads
+    segmentation-offloads
+    scaling
  
  .. only::  subproject
  
index 379063e5832600beb96504a65c96dda4fc727f8f,7a5165ee42804aa312cbb31d489af8ca8bb54c26..aa058aa7bf28b79e92fce0f141f0ec1214763262
@@@ -79,7 -79,6 +79,7 @@@ show up in /proc/sys/kernel
  - reboot-cmd                  [ SPARC only ]
  - rtsig-max
  - rtsig-nr
 +- sched_energy_aware
  - seccomp/                    ==> Documentation/userspace-api/seccomp_filter.rst
  - sem
  - sem_next_id               [ sysv ipc ]
@@@ -95,7 -94,7 +95,7 @@@
  - stop-a                      [ SPARC only ]
  - sysrq                       ==> Documentation/admin-guide/sysrq.rst
  - sysctl_writes_strict
- - tainted
+ - tainted                     ==> Documentation/admin-guide/tainted-kernels.rst
  - threads-max
  - unknown_nmi_panic
  - watchdog
@@@ -891,17 -890,6 +891,17 @@@ rtsig-nr shows the number of RT signal
  
  ==============================================================
  
 +sched_energy_aware:
 +
 +Enables/disables Energy Aware Scheduling (EAS). EAS starts
 +automatically on platforms where it can run (that is,
 +platforms with asymmetric CPU topologies and having an Energy
 +Model available). If your platform happens to meet the
 +requirements for EAS but you do not want to use it, change
 +this value to 0.
 +
 +==============================================================
 +
  sched_schedstats:
  
  Enables/disables scheduler statistics. Enabling this feature
@@@ -1031,39 -1019,33 +1031,33 @@@ compilation sees a 1% slowdown, other s
  
    1: kernel stack erasing is enabled (default), it is performed before
       returning to the userspace at the end of syscalls.
  ==============================================================
  
- tainted:
+ tainted
  
  Non-zero if the kernel has been tainted. Numeric values, which can be
  ORed together. The letters are seen in "Tainted" line of Oops reports.
  
-      1 (P):  A module with a non-GPL license has been loaded, this
-              includes modules with no license.
-              Set by modutils >= 2.4.9 and module-init-tools.
-      2 (F): A module was force loaded by insmod -f.
-             Set by modutils >= 2.4.9 and module-init-tools.
-      4 (S): Unsafe SMP processors: SMP with CPUs not designed for SMP.
-      8 (R): A module was forcibly unloaded from the system by rmmod -f.
-     16 (M): A hardware machine check error occurred on the system.
-     32 (B): A bad page was discovered on the system.
-     64 (U): The user has asked that the system be marked "tainted". This
-             could be because they are running software that directly modifies
-             the hardware, or for other reasons.
-    128 (D): The system has died.
-    256 (A): The ACPI DSDT has been overridden with one supplied by the user
-             instead of using the one provided by the hardware.
-    512 (W): A kernel warning has occurred.
-   1024 (C): A module from drivers/staging was loaded.
-   2048 (I): The system is working around a severe firmware bug.
-   4096 (O): An out-of-tree module has been loaded.
-   8192 (E): An unsigned module has been loaded in a kernel supporting module
-             signature.
-  16384 (L): A soft lockup has previously occurred on the system.
-  32768 (K): The kernel has been live patched.
-  65536 (X): Auxiliary taint, defined and used by for distros.
- 131072 (T): The kernel was built with the struct randomization plugin.
+      1 (P): proprietary module was loaded
+      2 (F): module was force loaded
+      4 (S): SMP kernel oops on an officially SMP incapable processor
+      8 (R): module was force unloaded
+     16 (M): processor reported a Machine Check Exception (MCE)
+     32 (B): bad page referenced or some unexpected page flags
+     64 (U): taint requested by userspace application
+    128 (D): kernel died recently, i.e. there was an OOPS or BUG
+    256 (A): an ACPI table was overridden by user
+    512 (W): kernel issued warning
+   1024 (C): staging driver was loaded
+   2048 (I): workaround for bug in platform firmware applied
+   4096 (O): externally-built ("out-of-tree") module was loaded
+   8192 (E): unsigned module was loaded
+  16384 (L): soft lockup occurred
+  32768 (K): kernel has been live patched
+  65536 (X): Auxiliary taint, defined and used by for distros
+ 131072 (T): The kernel was built with the struct randomization plugin
+ See Documentation/admin-guide/tainted-kernels.rst for more information.
  
  ==============================================================
  
diff --combined include/linux/module.h
index f5bc4c046461544ad366f0af68c261cb34d2a668,3a2402b8d790a602c50433cd76579bf49c046963..5bf5dcd91009eeac5f725ceb727f1f984e065458
@@@ -129,13 -129,13 +129,13 @@@ extern void cleanup_module(void)
  #define module_init(initfn)                                   \
        static inline initcall_t __maybe_unused __inittest(void)                \
        { return initfn; }                                      \
 -      int init_module(void) __attribute__((alias(#initfn)));
 +      int init_module(void) __copy(initfn) __attribute__((alias(#initfn)));
  
  /* This is only required if you want to be unloadable. */
  #define module_exit(exitfn)                                   \
        static inline exitcall_t __maybe_unused __exittest(void)                \
        { return exitfn; }                                      \
 -      void cleanup_module(void) __attribute__((alias(#exitfn)));
 +      void cleanup_module(void) __copy(exitfn) __attribute__((alias(#exitfn)));
  
  #endif
  
   * The following license idents are currently accepted as indicating free
   * software modules
   *
-  *    "GPL"                           [GNU Public License v2 or later]
+  *    "GPL"                           [GNU Public License v2]
   *    "GPL v2"                        [GNU Public License v2]
   *    "GPL and additional rights"     [GNU Public License v2 rights and more]
   *    "Dual BSD/GPL"                  [GNU Public License v2
   *
   *    "Proprietary"                   [Non free products]
   *
+  * Both "GPL v2" and "GPL" (the latter also in dual licensed strings) are
+  * merely stating that the module is licensed under the GPL v2, but are not
+  * telling whether "GPL v2 only" or "GPL v2 or later". The reason why there
+  * are two variants is a historic and failed attempt to convey more
+  * information in the MODULE_LICENSE string. For module loading the
+  * "only/or later" distinction is completely irrelevant and does neither
+  * replace the proper license identifiers in the corresponding source file
+  * nor amends them in any way. The sole purpose is to make the
+  * 'Proprietary' flagging work and to refuse to bind symbols which are
+  * exported with EXPORT_SYMBOL_GPL when a non free module is loaded.
+  *
+  * In the same way "BSD" is not a clear license information. It merely
+  * states, that the module is licensed under one of the compatible BSD
+  * license variants. The detailed and correct license information is again
+  * to be found in the corresponding source files.
+  *
   * There are dual licensed components, but when running with Linux it is the
   * GPL that is relevant so this is a non issue. Similarly LGPL linked with GPL
   * is a GPL combined work.
@@@ -828,7 -844,7 +844,7 @@@ static inline void module_bug_finalize(
  static inline void module_bug_cleanup(struct module *mod) {}
  #endif        /* CONFIG_GENERIC_BUG */
  
 -#ifdef RETPOLINE
 +#ifdef CONFIG_RETPOLINE
  extern bool retpoline_module_ok(bool has_retpoline);
  #else
  static inline bool retpoline_module_ok(bool has_retpoline)
diff --combined include/linux/skbuff.h
index 27beb549ffbe11eb1f8915c7ebc0c35e74d3523a,4e671b46e767ffcc5ab0181b75dae0bc28fd7085..b48bb8b42fc83f3cca1cd40ce3d937404388ccff
@@@ -1221,11 -1221,6 +1221,11 @@@ static inline int skb_flow_dissector_bp
  }
  #endif
  
 +struct bpf_flow_keys;
 +bool __skb_flow_bpf_dissect(struct bpf_prog *prog,
 +                          const struct sk_buff *skb,
 +                          struct flow_dissector *flow_dissector,
 +                          struct bpf_flow_keys *flow_keys);
  bool __skb_flow_dissect(const struct sk_buff *skb,
                        struct flow_dissector *flow_dissector,
                        void *target_container,
@@@ -1889,12 -1884,12 +1889,12 @@@ static inline void __skb_queue_before(s
   *
   *    A buffer cannot be placed on two lists at the same time.
   */
 -void skb_queue_head(struct sk_buff_head *list, struct sk_buff *newsk);
  static inline void __skb_queue_head(struct sk_buff_head *list,
                                    struct sk_buff *newsk)
  {
        __skb_queue_after(list, (struct sk_buff *)list, newsk);
  }
 +void skb_queue_head(struct sk_buff_head *list, struct sk_buff *newsk);
  
  /**
   *    __skb_queue_tail - queue a buffer at the list tail
   *
   *    A buffer cannot be placed on two lists at the same time.
   */
 -void skb_queue_tail(struct sk_buff_head *list, struct sk_buff *newsk);
  static inline void __skb_queue_tail(struct sk_buff_head *list,
                                   struct sk_buff *newsk)
  {
        __skb_queue_before(list, (struct sk_buff *)list, newsk);
  }
 +void skb_queue_tail(struct sk_buff_head *list, struct sk_buff *newsk);
  
  /*
   * remove sk_buff from list. _Must_ be called atomically, and with
@@@ -1938,6 -1933,7 +1938,6 @@@ static inline void __skb_unlink(struct 
   *    so must be used with appropriate locks held only. The head item is
   *    returned or %NULL if the list is empty.
   */
 -struct sk_buff *skb_dequeue(struct sk_buff_head *list);
  static inline struct sk_buff *__skb_dequeue(struct sk_buff_head *list)
  {
        struct sk_buff *skb = skb_peek(list);
                __skb_unlink(skb, list);
        return skb;
  }
 +struct sk_buff *skb_dequeue(struct sk_buff_head *list);
  
  /**
   *    __skb_dequeue_tail - remove from the tail of the queue
   *    so must be used with appropriate locks held only. The tail item is
   *    returned or %NULL if the list is empty.
   */
 -struct sk_buff *skb_dequeue_tail(struct sk_buff_head *list);
  static inline struct sk_buff *__skb_dequeue_tail(struct sk_buff_head *list)
  {
        struct sk_buff *skb = skb_peek_tail(list);
                __skb_unlink(skb, list);
        return skb;
  }
 +struct sk_buff *skb_dequeue_tail(struct sk_buff_head *list);
  
  
  static inline bool skb_is_nonlinear(const struct sk_buff *skb)
@@@ -2429,7 -2424,8 +2429,7 @@@ static inline void skb_pop_mac_header(s
        skb->mac_header = skb->network_header;
  }
  
 -static inline void skb_probe_transport_header(struct sk_buff *skb,
 -                                            const int offset_hint)
 +static inline void skb_probe_transport_header(struct sk_buff *skb)
  {
        struct flow_keys_basic keys;
  
  
        if (skb_flow_dissect_flow_keys_basic(skb, &keys, NULL, 0, 0, 0, 0))
                skb_set_transport_header(skb, keys.control.thoff);
 -      else
 -              skb_set_transport_header(skb, offset_hint);
  }
  
  static inline void skb_mac_header_rebuild(struct sk_buff *skb)
@@@ -2650,13 -2648,13 +2650,13 @@@ static inline int skb_orphan_frags_rx(s
   *    the list and one reference dropped. This function does not take the
   *    list lock and the caller must hold the relevant locks to use it.
   */
 -void skb_queue_purge(struct sk_buff_head *list);
  static inline void __skb_queue_purge(struct sk_buff_head *list)
  {
        struct sk_buff *skb;
        while ((skb = __skb_dequeue(list)) != NULL)
                kfree_skb(skb);
  }
 +void skb_queue_purge(struct sk_buff_head *list);
  
  unsigned int skb_rbtree_purge(struct rb_root *root);
  
@@@ -3025,7 -3023,7 +3025,7 @@@ static inline int skb_padto(struct sk_b
  }
  
  /**
 - *    skb_put_padto - increase size and pad an skbuff up to a minimal size
 + *    __skb_put_padto - increase size and pad an skbuff up to a minimal size
   *    @skb: buffer to pad
   *    @len: minimal length
   *    @free_on_error: free buffer on error
@@@ -3220,7 -3218,6 +3220,7 @@@ int pskb_trim_rcsum_slow(struct sk_buf
   *
   *    This is exactly the same as pskb_trim except that it ensures the
   *    checksum of received packets are still valid after the operation.
 + *    It can change skb pointers.
   */
  
  static inline int pskb_trim_rcsum(struct sk_buff *skb, unsigned int len)
@@@ -3483,25 -3480,16 +3483,25 @@@ static inline ktime_t skb_get_ktime(con
  /**
   *    skb_get_timestamp - get timestamp from a skb
   *    @skb: skb to get stamp from
 - *    @stamp: pointer to struct timeval to store stamp in
 + *    @stamp: pointer to struct __kernel_old_timeval to store stamp in
   *
   *    Timestamps are stored in the skb as offsets to a base timestamp.
   *    This function converts the offset back to a struct timeval and stores
   *    it in stamp.
   */
  static inline void skb_get_timestamp(const struct sk_buff *skb,
 -                                   struct timeval *stamp)
 +                                   struct __kernel_old_timeval *stamp)
  {
 -      *stamp = ktime_to_timeval(skb->tstamp);
 +      *stamp = ns_to_kernel_old_timeval(skb->tstamp);
 +}
 +
 +static inline void skb_get_new_timestamp(const struct sk_buff *skb,
 +                                       struct __kernel_sock_timeval *stamp)
 +{
 +      struct timespec64 ts = ktime_to_timespec64(skb->tstamp);
 +
 +      stamp->tv_sec = ts.tv_sec;
 +      stamp->tv_usec = ts.tv_nsec / 1000;
  }
  
  static inline void skb_get_timestampns(const struct sk_buff *skb,
        *stamp = ktime_to_timespec(skb->tstamp);
  }
  
 +static inline void skb_get_new_timestampns(const struct sk_buff *skb,
 +                                         struct __kernel_timespec *stamp)
 +{
 +      struct timespec64 ts = ktime_to_timespec64(skb->tstamp);
 +
 +      stamp->tv_sec = ts.tv_sec;
 +      stamp->tv_nsec = ts.tv_nsec;
 +}
 +
  static inline void __net_timestamp(struct sk_buff *skb)
  {
        skb->tstamp = ktime_get_real();
@@@ -4232,12 -4211,6 +4232,12 @@@ static inline bool skb_is_gso_sctp(cons
        return skb_shinfo(skb)->gso_type & SKB_GSO_SCTP;
  }
  
 +static inline bool skb_is_gso_tcp(const struct sk_buff *skb)
 +{
 +      return skb_is_gso(skb) &&
 +             skb_shinfo(skb)->gso_type & (SKB_GSO_TCPV4 | SKB_GSO_TCPV6);
 +}
 +
  static inline void skb_gso_reset(struct sk_buff *skb)
  {
        skb_shinfo(skb)->gso_size = 0;
@@@ -4323,7 -4296,7 +4323,7 @@@ static inline bool skb_head_is_locked(c
  /* Local Checksum Offload.
   * Compute outer checksum based on the assumption that the
   * inner checksum will be offloaded later.
-  * See Documentation/networking/checksum-offloads.txt for
+  * See Documentation/networking/checksum-offloads.rst for
   * explanation of how this works.
   * Fill in outer checksum adjustment (e.g. with sum of outer
   * pseudo-header) before calling.
diff --combined scripts/checkpatch.pl
index 8d8d26b5cbbd8913b649ef6556050f1795f018d5,d62abd032885a10b9ae34e5f55205ffea7f62c4e..5b756278df13e8aa7f5daf92914858afbfd24482
@@@ -61,7 -61,7 +61,7 @@@ my $codespellfile = "/usr/share/codespe
  my $conststructsfile = "$D/const_structs.checkpatch";
  my $typedefsfile = "";
  my $color = "auto";
 -my $allow_c99_comments = 1;
 +my $allow_c99_comments = 1; # Can be overridden by --ignore C99_COMMENT_TOLERANCE
  
  sub help {
        my ($exitcode) = @_;
@@@ -466,16 -466,6 +466,16 @@@ our $logFunctions = qr{(?x
        seq_vprintf|seq_printf|seq_puts
  )};
  
 +our $allocFunctions = qr{(?x:
 +      (?:(?:devm_)?
 +              (?:kv|k|v)[czm]alloc(?:_node|_array)? |
 +              kstrdup(?:_const)? |
 +              kmemdup(?:_nul)?) |
 +      (?:\w+)?alloc_skb(?:ip_align)? |
 +                              # dev_alloc_skb/netdev_alloc_skb, et al
 +      dma_alloc_coherent
 +)};
 +
  our $signature_tags = qr{(?xi:
        Signed-off-by:|
        Co-developed-by:|
@@@ -1021,7 -1011,6 +1021,7 @@@ if ($git) 
  }
  
  my $vname;
 +$allow_c99_comments = !defined $ignore_type{"C99_COMMENT_TOLERANCE"};
  for my $filename (@ARGV) {
        my $FILE;
        if ($git) {
@@@ -3048,14 -3037,6 +3048,14 @@@ sub process 
                                        $comment = '..';
                                }
  
 +# check SPDX comment style for .[chsS] files
 +                              if ($realfile =~ /\.[chsS]$/ &&
 +                                  $rawline =~ /SPDX-License-Identifier:/ &&
 +                                  $rawline !~ /^\+\s*\Q$comment\E\s*/) {
 +                                      WARN("SPDX_LICENSE_TAG",
 +                                           "Improper SPDX comment style for '$realfile', please use '$comment' instead\n" . $herecurr);
 +                              }
 +
                                if ($comment !~ /^$/ &&
                                    $rawline !~ /^\+\Q$comment\E SPDX-License-Identifier: /) {
                                         WARN("SPDX_LICENSE_TAG",
  # check we are in a valid source file if not then ignore this hunk
                next if ($realfile !~ /\.(h|c|s|S|sh|dtsi|dts)$/);
  
 +# check for using SPDX-License-Identifier on the wrong line number
 +              if ($realline != $checklicenseline &&
 +                  $rawline =~ /\bSPDX-License-Identifier:/ &&
 +                  substr($line, @-, @+ - @-) eq "$;" x (@+ - @-)) {
 +                      WARN("SPDX_LICENSE_TAG",
 +                           "Misplaced SPDX-License-Identifier tag - use line $checklicenseline instead\n" . $herecurr);
 +              }
 +
  # line length limit (with some exclusions)
  #
  # There are a few types of lines that may extend beyond $max_line_length:
                        my ($s, $c) = ctx_statement_block($linenr - 3, $realcnt, 0);
  #                     print("line: <$line>\nprevline: <$prevline>\ns: <$s>\nc: <$c>\n\n\n");
  
 -                      if ($s =~ /(?:^|\n)[ \+]\s*(?:$Type\s*)?\Q$testval\E\s*=\s*(?:\([^\)]*\)\s*)?\s*(?:devm_)?(?:[kv][czm]alloc(?:_node|_array)?\b|kstrdup|kmemdup|(?:dev_)?alloc_skb)/) {
 +                      if ($s =~ /(?:^|\n)[ \+]\s*(?:$Type\s*)?\Q$testval\E\s*=\s*(?:\([^\)]*\)\s*)?\s*$allocFunctions\s*\(/ &&
 +                          $s !~ /\b__GFP_NOWARN\b/ ) {
                                WARN("OOM_MESSAGE",
                                     "Possible unnecessary 'out of memory' message\n" . $hereprev);
                        }
                        }
                }
  
 -# check for pointless casting of kmalloc return
 -              if ($line =~ /\*\s*\)\s*[kv][czm]alloc(_node){0,1}\b/) {
 +# check for pointless casting of alloc functions
 +              if ($line =~ /\*\s*\)\s*$allocFunctions\b/) {
                        WARN("UNNECESSARY_CASTS",
                             "unnecessary cast may hide bugs, see http://c-faq.com/malloc/mallocnocast.html\n" . $herecurr);
                }
  # alloc style
  # p = alloc(sizeof(struct foo), ...) should be p = alloc(sizeof(*p), ...)
                if ($perl_version_ok &&
 -                  $line =~ /\b($Lval)\s*\=\s*(?:$balanced_parens)?\s*([kv][mz]alloc(?:_node)?)\s*\(\s*(sizeof\s*\(\s*struct\s+$Lval\s*\))/) {
 +                  $line =~ /\b($Lval)\s*\=\s*(?:$balanced_parens)?\s*((?:kv|k|v)[mz]alloc(?:_node)?)\s*\(\s*(sizeof\s*\(\s*struct\s+$Lval\s*\))/) {
                        CHK("ALLOC_SIZEOF_STRUCT",
                            "Prefer $3(sizeof(*$1)...) over $3($4...)\n" . $herecurr);
                }
                        }
                }
  
- # check for bool bitfields
-               if ($sline =~ /^.\s+bool\s*$Ident\s*:\s*\d+\s*;/) {
-                       WARN("BOOL_BITFIELD",
-                            "Avoid using bool as bitfield.  Prefer bool bitfields as unsigned int or u<8|16|32>\n" . $herecurr);
-               }
- # check for bool use in .h files
-               if ($realfile =~ /\.h$/ &&
-                   $sline =~ /^.\s+bool\s*$Ident\s*(?::\s*d+\s*)?;/) {
-                       CHK("BOOL_MEMBER",
-                           "Avoid using bool structure members because of possible alignment issues - see: https://lkml.org/lkml/2017/11/21/384\n" . $herecurr);
-               }
  # check for semaphores initialized locked
                if ($line =~ /^.\s*sema_init.+,\W?0\W?\)/) {
                        WARN("CONSIDER_COMPLETION",
diff --combined security/selinux/hooks.c
index 2f82a54f870382440b621fde195ce69859bd286a,bb4a8e088f7ed0181cbf1b2e8474808c987e15c0..333606b3a8efdd598c087314d1fa1874b068f659
@@@ -79,6 -79,7 +79,6 @@@
  #include <linux/personality.h>
  #include <linux/audit.h>
  #include <linux/string.h>
 -#include <linux/selinux.h>
  #include <linux/mutex.h>
  #include <linux/posix-timers.h>
  #include <linux/syslog.h>
@@@ -120,8 -121,9 +120,8 @@@ __setup("enforcing=", enforcing_setup)
  #define selinux_enforcing_boot 1
  #endif
  
 +int selinux_enabled __lsm_ro_after_init = 1;
  #ifdef CONFIG_SECURITY_SELINUX_BOOTPARAM
 -int selinux_enabled = CONFIG_SECURITY_SELINUX_BOOTPARAM_VALUE;
 -
  static int __init selinux_enabled_setup(char *str)
  {
        unsigned long enabled;
        return 1;
  }
  __setup("selinux=", selinux_enabled_setup);
 -#else
 -int selinux_enabled = 1;
  #endif
  
  static unsigned int selinux_checkreqprot_boot =
@@@ -145,6 -149,9 +145,6 @@@ static int __init checkreqprot_setup(ch
  }
  __setup("checkreqprot=", checkreqprot_setup);
  
 -static struct kmem_cache *sel_inode_cache;
 -static struct kmem_cache *file_security_cache;
 -
  /**
   * selinux_secmark_enabled - Check to see if SECMARK is currently enabled
   *
@@@ -207,8 -214,12 +207,8 @@@ static void cred_init_security(void
        struct cred *cred = (struct cred *) current->real_cred;
        struct task_security_struct *tsec;
  
 -      tsec = kzalloc(sizeof(struct task_security_struct), GFP_KERNEL);
 -      if (!tsec)
 -              panic("SELinux:  Failed to initialize initial task.\n");
 -
 +      tsec = selinux_cred(cred);
        tsec->osid = tsec->sid = SECINITSID_KERNEL;
 -      cred->security = tsec;
  }
  
  /*
@@@ -218,7 -229,7 +218,7 @@@ static inline u32 cred_sid(const struc
  {
        const struct task_security_struct *tsec;
  
 -      tsec = cred->security;
 +      tsec = selinux_cred(cred);
        return tsec->sid;
  }
  
@@@ -239,9 -250,13 +239,9 @@@ static inline u32 task_sid(const struc
  
  static int inode_alloc_security(struct inode *inode)
  {
 -      struct inode_security_struct *isec;
 +      struct inode_security_struct *isec = selinux_inode(inode);
        u32 sid = current_sid();
  
 -      isec = kmem_cache_zalloc(sel_inode_cache, GFP_NOFS);
 -      if (!isec)
 -              return -ENOMEM;
 -
        spin_lock_init(&isec->lock);
        INIT_LIST_HEAD(&isec->list);
        isec->inode = inode;
        isec->sclass = SECCLASS_FILE;
        isec->task_sid = sid;
        isec->initialized = LABEL_INVALID;
 -      inode->i_security = isec;
  
        return 0;
  }
@@@ -265,7 -281,7 +265,7 @@@ static int __inode_security_revalidate(
                                       struct dentry *dentry,
                                       bool may_sleep)
  {
 -      struct inode_security_struct *isec = inode->i_security;
 +      struct inode_security_struct *isec = selinux_inode(inode);
  
        might_sleep_if(may_sleep);
  
  
  static struct inode_security_struct *inode_security_novalidate(struct inode *inode)
  {
 -      return inode->i_security;
 +      return selinux_inode(inode);
  }
  
  static struct inode_security_struct *inode_security_rcu(struct inode *inode, bool rcu)
        error = __inode_security_revalidate(inode, NULL, !rcu);
        if (error)
                return ERR_PTR(error);
 -      return inode->i_security;
 +      return selinux_inode(inode);
  }
  
  /*
  static struct inode_security_struct *inode_security(struct inode *inode)
  {
        __inode_security_revalidate(inode, NULL, true);
 -      return inode->i_security;
 +      return selinux_inode(inode);
  }
  
  static struct inode_security_struct *backing_inode_security_novalidate(struct dentry *dentry)
  {
        struct inode *inode = d_backing_inode(dentry);
  
 -      return inode->i_security;
 +      return selinux_inode(inode);
  }
  
  /*
@@@ -323,17 -339,22 +323,17 @@@ static struct inode_security_struct *ba
        struct inode *inode = d_backing_inode(dentry);
  
        __inode_security_revalidate(inode, dentry, true);
 -      return inode->i_security;
 -}
 -
 -static void inode_free_rcu(struct rcu_head *head)
 -{
 -      struct inode_security_struct *isec;
 -
 -      isec = container_of(head, struct inode_security_struct, rcu);
 -      kmem_cache_free(sel_inode_cache, isec);
 +      return selinux_inode(inode);
  }
  
  static void inode_free_security(struct inode *inode)
  {
 -      struct inode_security_struct *isec = inode->i_security;
 -      struct superblock_security_struct *sbsec = inode->i_sb->s_security;
 +      struct inode_security_struct *isec = selinux_inode(inode);
 +      struct superblock_security_struct *sbsec;
  
 +      if (!isec)
 +              return;
 +      sbsec = inode->i_sb->s_security;
        /*
         * As not all inode security structures are in a list, we check for
         * empty list outside of the lock to make sure that we won't waste
                list_del_init(&isec->list);
                spin_unlock(&sbsec->isec_lock);
        }
 -
 -      /*
 -       * The inode may still be referenced in a path walk and
 -       * a call to selinux_inode_permission() can be made
 -       * after inode_free_security() is called. Ideally, the VFS
 -       * wouldn't do this, but fixing that is a much harder
 -       * job. For now, simply free the i_security via RCU, and
 -       * leave the current inode->i_security pointer intact.
 -       * The inode will be freed after the RCU grace period too.
 -       */
 -      call_rcu(&isec->rcu, inode_free_rcu);
  }
  
  static int file_alloc_security(struct file *file)
  {
 -      struct file_security_struct *fsec;
 +      struct file_security_struct *fsec = selinux_file(file);
        u32 sid = current_sid();
  
 -      fsec = kmem_cache_zalloc(file_security_cache, GFP_KERNEL);
 -      if (!fsec)
 -              return -ENOMEM;
 -
        fsec->sid = sid;
        fsec->fown_sid = sid;
 -      file->f_security = fsec;
  
        return 0;
  }
  
 -static void file_free_security(struct file *file)
 -{
 -      struct file_security_struct *fsec = file->f_security;
 -      file->f_security = NULL;
 -      kmem_cache_free(file_security_cache, fsec);
 -}
 -
  static int superblock_alloc_security(struct super_block *sb)
  {
        struct superblock_security_struct *sbsec;
@@@ -457,7 -501,7 +457,7 @@@ static int may_context_mount_sb_relabel
                        struct superblock_security_struct *sbsec,
                        const struct cred *cred)
  {
 -      const struct task_security_struct *tsec = cred->security;
 +      const struct task_security_struct *tsec = selinux_cred(cred);
        int rc;
  
        rc = avc_has_perm(&selinux_state,
@@@ -476,7 -520,7 +476,7 @@@ static int may_context_mount_inode_rela
                        struct superblock_security_struct *sbsec,
                        const struct cred *cred)
  {
 -      const struct task_security_struct *tsec = cred->security;
 +      const struct task_security_struct *tsec = selinux_cred(cred);
        int rc;
        rc = avc_has_perm(&selinux_state,
                          tsec->sid, sbsec->sid, SECCLASS_FILESYSTEM,
        return rc;
  }
  
 -static int selinux_is_sblabel_mnt(struct super_block *sb)
 +static int selinux_is_genfs_special_handling(struct super_block *sb)
  {
 -      struct superblock_security_struct *sbsec = sb->s_security;
 -
 -      return sbsec->behavior == SECURITY_FS_USE_XATTR ||
 -              sbsec->behavior == SECURITY_FS_USE_TRANS ||
 -              sbsec->behavior == SECURITY_FS_USE_TASK ||
 -              sbsec->behavior == SECURITY_FS_USE_NATIVE ||
 -              /* Special handling. Genfs but also in-core setxattr handler */
 -              !strcmp(sb->s_type->name, "sysfs") ||
 +      /* Special handling. Genfs but also in-core setxattr handler */
 +      return  !strcmp(sb->s_type->name, "sysfs") ||
                !strcmp(sb->s_type->name, "pstore") ||
                !strcmp(sb->s_type->name, "debugfs") ||
                !strcmp(sb->s_type->name, "tracefs") ||
                  !strcmp(sb->s_type->name, "cgroup2")));
  }
  
 +static int selinux_is_sblabel_mnt(struct super_block *sb)
 +{
 +      struct superblock_security_struct *sbsec = sb->s_security;
 +
 +      /*
 +       * IMPORTANT: Double-check logic in this function when adding a new
 +       * SECURITY_FS_USE_* definition!
 +       */
 +      BUILD_BUG_ON(SECURITY_FS_USE_MAX != 7);
 +
 +      switch (sbsec->behavior) {
 +      case SECURITY_FS_USE_XATTR:
 +      case SECURITY_FS_USE_TRANS:
 +      case SECURITY_FS_USE_TASK:
 +      case SECURITY_FS_USE_NATIVE:
 +              return 1;
 +
 +      case SECURITY_FS_USE_GENFS:
 +              return selinux_is_genfs_special_handling(sb);
 +
 +      /* Never allow relabeling on context mounts */
 +      case SECURITY_FS_USE_MNTPOINT:
 +      case SECURITY_FS_USE_NONE:
 +      default:
 +              return 0;
 +      }
 +}
 +
  static int sb_finish_set_opts(struct super_block *sb)
  {
        struct superblock_security_struct *sbsec = sb->s_security;
@@@ -1352,7 -1374,7 +1352,7 @@@ static int selinux_genfs_get_sid(struc
  static int inode_doinit_with_dentry(struct inode *inode, struct dentry *opt_dentry)
  {
        struct superblock_security_struct *sbsec = NULL;
 -      struct inode_security_struct *isec = inode->i_security;
 +      struct inode_security_struct *isec = selinux_inode(inode);
        u32 task_sid, sid = 0;
        u16 sclass;
        struct dentry *dentry;
@@@ -1599,7 -1621,7 +1599,7 @@@ static inline u32 signal_to_av(int sig
  
  /* Check whether a task is allowed to use a capability. */
  static int cred_has_capability(const struct cred *cred,
 -                             int cap, int audit, bool initns)
 +                             int cap, unsigned int opts, bool initns)
  {
        struct common_audit_data ad;
        struct av_decision avd;
  
        rc = avc_has_perm_noaudit(&selinux_state,
                                  sid, sid, sclass, av, 0, &avd);
 -      if (audit == SECURITY_CAP_AUDIT) {
 +      if (!(opts & CAP_OPT_NOAUDIT)) {
                int rc2 = avc_audit(&selinux_state,
                                    sid, sid, sclass, av, &avd, rc, &ad, 0);
                if (rc2)
@@@ -1652,7 -1674,7 +1652,7 @@@ static int inode_has_perm(const struct 
                return 0;
  
        sid = cred_sid(cred);
 -      isec = inode->i_security;
 +      isec = selinux_inode(inode);
  
        return avc_has_perm(&selinux_state,
                            sid, isec->sid, isec->sclass, perms, adp);
@@@ -1718,7 -1740,7 +1718,7 @@@ static int file_has_perm(const struct c
                         struct file *file,
                         u32 av)
  {
 -      struct file_security_struct *fsec = file->f_security;
 +      struct file_security_struct *fsec = selinux_file(file);
        struct inode *inode = file_inode(file);
        struct common_audit_data ad;
        u32 sid = cred_sid(cred);
@@@ -1784,7 -1806,7 +1784,7 @@@ static int may_create(struct inode *dir
                      struct dentry *dentry,
                      u16 tclass)
  {
 -      const struct task_security_struct *tsec = current_security();
 +      const struct task_security_struct *tsec = selinux_cred(current_cred());
        struct inode_security_struct *dsec;
        struct superblock_security_struct *sbsec;
        u32 sid, newsid;
        if (rc)
                return rc;
  
 -      rc = selinux_determine_inode_label(current_security(), dir,
 +      rc = selinux_determine_inode_label(selinux_cred(current_cred()), dir,
                                           &dentry->d_name, tclass, &newsid);
        if (rc)
                return rc;
@@@ -2062,7 -2084,7 +2062,7 @@@ static int selinux_binder_transfer_file
                                        struct file *file)
  {
        u32 sid = task_sid(to);
 -      struct file_security_struct *fsec = file->f_security;
 +      struct file_security_struct *fsec = selinux_file(file);
        struct dentry *dentry = file->f_path.dentry;
        struct inode_security_struct *isec;
        struct common_audit_data ad;
@@@ -2146,9 -2168,9 +2146,9 @@@ static int selinux_capset(struct cred *
   */
  
  static int selinux_capable(const struct cred *cred, struct user_namespace *ns,
 -                         int cap, int audit)
 +                         int cap, unsigned int opts)
  {
 -      return cred_has_capability(cred, cap, audit, ns == &init_user_ns);
 +      return cred_has_capability(cred, cap, opts, ns == &init_user_ns);
  }
  
  static int selinux_quotactl(int cmds, int type, int id, struct super_block *sb)
@@@ -2222,7 -2244,7 +2222,7 @@@ static int selinux_vm_enough_memory(str
        int rc, cap_sys_admin = 0;
  
        rc = cred_has_capability(current_cred(), CAP_SYS_ADMIN,
 -                               SECURITY_CAP_NOAUDIT, true);
 +                               CAP_OPT_NOAUDIT, true);
        if (rc == 0)
                cap_sys_admin = 1;
  
@@@ -2313,8 -2335,8 +2313,8 @@@ static int selinux_bprm_set_creds(struc
        if (bprm->called_set_creds)
                return 0;
  
 -      old_tsec = current_security();
 -      new_tsec = bprm->cred->security;
 +      old_tsec = selinux_cred(current_cred());
 +      new_tsec = selinux_cred(bprm->cred);
        isec = inode_security(inode);
  
        /* Default to the current task SID. */
@@@ -2478,7 -2500,7 +2478,7 @@@ static void selinux_bprm_committing_cre
        struct rlimit *rlim, *initrlim;
        int rc, i;
  
 -      new_tsec = bprm->cred->security;
 +      new_tsec = selinux_cred(bprm->cred);
        if (new_tsec->sid == new_tsec->osid)
                return;
  
   */
  static void selinux_bprm_committed_creds(struct linux_binprm *bprm)
  {
 -      const struct task_security_struct *tsec = current_security();
 +      const struct task_security_struct *tsec = selinux_cred(current_cred());
        struct itimerval itimer;
        u32 osid, sid;
        int rc, i;
@@@ -2758,7 -2780,7 +2758,7 @@@ static int selinux_dentry_init_security
        u32 newsid;
        int rc;
  
 -      rc = selinux_determine_inode_label(current_security(),
 +      rc = selinux_determine_inode_label(selinux_cred(current_cred()),
                                           d_inode(dentry->d_parent), name,
                                           inode_mode_to_security_class(mode),
                                           &newsid);
@@@ -2778,14 -2800,14 +2778,14 @@@ static int selinux_dentry_create_files_
        int rc;
        struct task_security_struct *tsec;
  
 -      rc = selinux_determine_inode_label(old->security,
 +      rc = selinux_determine_inode_label(selinux_cred(old),
                                           d_inode(dentry->d_parent), name,
                                           inode_mode_to_security_class(mode),
                                           &newsid);
        if (rc)
                return rc;
  
 -      tsec = new->security;
 +      tsec = selinux_cred(new);
        tsec->create_sid = newsid;
        return 0;
  }
@@@ -2795,7 -2817,7 +2795,7 @@@ static int selinux_inode_init_security(
                                       const char **name,
                                       void **value, size_t *len)
  {
 -      const struct task_security_struct *tsec = current_security();
 +      const struct task_security_struct *tsec = selinux_cred(current_cred());
        struct superblock_security_struct *sbsec;
        u32 newsid, clen;
        int rc;
  
        newsid = tsec->create_sid;
  
 -      rc = selinux_determine_inode_label(current_security(),
 +      rc = selinux_determine_inode_label(selinux_cred(current_cred()),
                dir, qstr,
                inode_mode_to_security_class(inode->i_mode),
                &newsid);
  
        /* Possibly defer initialization to selinux_complete_init. */
        if (sbsec->flags & SE_SBINITIALIZED) {
 -              struct inode_security_struct *isec = inode->i_security;
 +              struct inode_security_struct *isec = selinux_inode(inode);
                isec->sclass = inode_mode_to_security_class(inode->i_mode);
                isec->sid = newsid;
                isec->initialized = LABEL_INITIALIZED;
@@@ -2903,8 -2925,9 +2903,8 @@@ static int selinux_inode_follow_link(st
        if (IS_ERR(isec))
                return PTR_ERR(isec);
  
 -      return avc_has_perm_flags(&selinux_state,
 -                                sid, isec->sid, isec->sclass, FILE__READ, &ad,
 -                                rcu ? MAY_NOT_BLOCK : 0);
 +      return avc_has_perm(&selinux_state,
 +                          sid, isec->sid, isec->sclass, FILE__READ, &ad);
  }
  
  static noinline int audit_inode_permission(struct inode *inode,
                                           unsigned flags)
  {
        struct common_audit_data ad;
 -      struct inode_security_struct *isec = inode->i_security;
 +      struct inode_security_struct *isec = selinux_inode(inode);
        int rc;
  
        ad.type = LSM_AUDIT_DATA_INODE;
@@@ -2959,9 -2982,7 +2959,9 @@@ static int selinux_inode_permission(str
                return PTR_ERR(isec);
  
        rc = avc_has_perm_noaudit(&selinux_state,
 -                                sid, isec->sid, isec->sclass, perms, 0, &avd);
 +                                sid, isec->sid, isec->sclass, perms,
 +                                (flags & MAY_NOT_BLOCK) ? AVC_NONBLOCKING : 0,
 +                                &avd);
        audited = avc_audit_required(perms, &avd, rc,
                                     from_access ? FILE__AUDIT_ACCESS : 0,
                                     &denied);
@@@ -3010,11 -3031,11 +3010,11 @@@ static int selinux_inode_getattr(const 
  static bool has_cap_mac_admin(bool audit)
  {
        const struct cred *cred = current_cred();
 -      int cap_audit = audit ? SECURITY_CAP_AUDIT : SECURITY_CAP_NOAUDIT;
 +      unsigned int opts = audit ? CAP_OPT_NONE : CAP_OPT_NOAUDIT;
  
 -      if (cap_capable(cred, &init_user_ns, CAP_MAC_ADMIN, cap_audit))
 +      if (cap_capable(cred, &init_user_ns, CAP_MAC_ADMIN, opts))
                return false;
 -      if (cred_has_capability(cred, CAP_MAC_ADMIN, cap_audit, true))
 +      if (cred_has_capability(cred, CAP_MAC_ADMIN, opts, true))
                return false;
        return true;
  }
@@@ -3220,16 -3241,12 +3220,16 @@@ static int selinux_inode_setsecurity(st
                                     const void *value, size_t size, int flags)
  {
        struct inode_security_struct *isec = inode_security_novalidate(inode);
 +      struct superblock_security_struct *sbsec = inode->i_sb->s_security;
        u32 newsid;
        int rc;
  
        if (strcmp(name, XATTR_SELINUX_SUFFIX))
                return -EOPNOTSUPP;
  
 +      if (!(sbsec->flags & SBLABEL_MNT))
 +              return -EOPNOTSUPP;
 +
        if (!value || !size)
                return -EACCES;
  
@@@ -3272,7 -3289,7 +3272,7 @@@ static int selinux_inode_copy_up(struc
                        return -ENOMEM;
        }
  
 -      tsec = new_creds->security;
 +      tsec = selinux_cred(new_creds);
        /* Get label from overlay inode and set it in create_sid */
        selinux_inode_getsecid(d_inode(src), &sid);
        tsec->create_sid = sid;
@@@ -3313,7 -3330,7 +3313,7 @@@ static int selinux_revalidate_file_perm
  static int selinux_file_permission(struct file *file, int mask)
  {
        struct inode *inode = file_inode(file);
 -      struct file_security_struct *fsec = file->f_security;
 +      struct file_security_struct *fsec = selinux_file(file);
        struct inode_security_struct *isec;
        u32 sid = current_sid();
  
@@@ -3335,6 -3352,11 +3335,6 @@@ static int selinux_file_alloc_security(
        return file_alloc_security(file);
  }
  
 -static void selinux_file_free_security(struct file *file)
 -{
 -      file_free_security(file);
 -}
 -
  /*
   * Check whether a task has the ioctl permission and cmd
   * operation to an inode.
@@@ -3343,7 -3365,7 +3343,7 @@@ static int ioctl_has_perm(const struct 
                u32 requested, u16 cmd)
  {
        struct common_audit_data ad;
 -      struct file_security_struct *fsec = file->f_security;
 +      struct file_security_struct *fsec = selinux_file(file);
        struct inode *inode = file_inode(file);
        struct inode_security_struct *isec;
        struct lsm_ioctlop_audit ioctl;
@@@ -3413,7 -3435,7 +3413,7 @@@ static int selinux_file_ioctl(struct fi
        case KDSKBENT:
        case KDSKBSENT:
                error = cred_has_capability(cred, CAP_SYS_TTY_CONFIG,
 -                                          SECURITY_CAP_AUDIT, true);
 +                                          CAP_OPT_NONE, true);
                break;
  
        /* default case assumes that the command will go
@@@ -3595,7 -3617,7 +3595,7 @@@ static void selinux_file_set_fowner(str
  {
        struct file_security_struct *fsec;
  
 -      fsec = file->f_security;
 +      fsec = selinux_file(file);
        fsec->fown_sid = current_sid();
  }
  
@@@ -3610,7 -3632,7 +3610,7 @@@ static int selinux_file_send_sigiotask(
        /* struct fown_struct is never outside the context of a struct file */
        file = container_of(fown, struct file, f_owner);
  
 -      fsec = file->f_security;
 +      fsec = selinux_file(file);
  
        if (!signum)
                perm = signal_to_av(SIGIO); /* as per send_sigio_to_task */
@@@ -3634,7 -3656,7 +3634,7 @@@ static int selinux_file_open(struct fil
        struct file_security_struct *fsec;
        struct inode_security_struct *isec;
  
 -      fsec = file->f_security;
 +      fsec = selinux_file(file);
        isec = inode_security(file_inode(file));
        /*
         * Save inode label and policy sequence number
@@@ -3667,16 -3689,53 +3667,16 @@@ static int selinux_task_alloc(struct ta
                            sid, sid, SECCLASS_PROCESS, PROCESS__FORK, NULL);
  }
  
 -/*
 - * allocate the SELinux part of blank credentials
 - */
 -static int selinux_cred_alloc_blank(struct cred *cred, gfp_t gfp)
 -{
 -      struct task_security_struct *tsec;
 -
 -      tsec = kzalloc(sizeof(struct task_security_struct), gfp);
 -      if (!tsec)
 -              return -ENOMEM;
 -
 -      cred->security = tsec;
 -      return 0;
 -}
 -
 -/*
 - * detach and free the LSM part of a set of credentials
 - */
 -static void selinux_cred_free(struct cred *cred)
 -{
 -      struct task_security_struct *tsec = cred->security;
 -
 -      /*
 -       * cred->security == NULL if security_cred_alloc_blank() or
 -       * security_prepare_creds() returned an error.
 -       */
 -      BUG_ON(cred->security && (unsigned long) cred->security < PAGE_SIZE);
 -      cred->security = (void *) 0x7UL;
 -      kfree(tsec);
 -}
 -
  /*
   * prepare a new set of credentials for modification
   */
  static int selinux_cred_prepare(struct cred *new, const struct cred *old,
                                gfp_t gfp)
  {
 -      const struct task_security_struct *old_tsec;
 -      struct task_security_struct *tsec;
 -
 -      old_tsec = old->security;
 -
 -      tsec = kmemdup(old_tsec, sizeof(struct task_security_struct), gfp);
 -      if (!tsec)
 -              return -ENOMEM;
 +      const struct task_security_struct *old_tsec = selinux_cred(old);
 +      struct task_security_struct *tsec = selinux_cred(new);
  
 -      new->security = tsec;
 +      *tsec = *old_tsec;
        return 0;
  }
  
   */
  static void selinux_cred_transfer(struct cred *new, const struct cred *old)
  {
 -      const struct task_security_struct *old_tsec = old->security;
 -      struct task_security_struct *tsec = new->security;
 +      const struct task_security_struct *old_tsec = selinux_cred(old);
 +      struct task_security_struct *tsec = selinux_cred(new);
  
        *tsec = *old_tsec;
  }
@@@ -3702,7 -3761,7 +3702,7 @@@ static void selinux_cred_getsecid(cons
   */
  static int selinux_kernel_act_as(struct cred *new, u32 secid)
  {
 -      struct task_security_struct *tsec = new->security;
 +      struct task_security_struct *tsec = selinux_cred(new);
        u32 sid = current_sid();
        int ret;
  
  static int selinux_kernel_create_files_as(struct cred *new, struct inode *inode)
  {
        struct inode_security_struct *isec = inode_security(inode);
 -      struct task_security_struct *tsec = new->security;
 +      struct task_security_struct *tsec = selinux_cred(new);
        u32 sid = current_sid();
        int ret;
  
@@@ -3773,7 -3832,7 +3773,7 @@@ static int selinux_kernel_module_from_f
        ad.type = LSM_AUDIT_DATA_FILE;
        ad.u.file = file;
  
 -      fsec = file->f_security;
 +      fsec = selinux_file(file);
        if (sid != fsec->sid) {
                rc = avc_has_perm(&selinux_state,
                                  sid, fsec->sid, SECCLASS_FD, FD__USE, &ad);
@@@ -3939,7 -3998,7 +3939,7 @@@ static int selinux_task_kill(struct tas
  static void selinux_task_to_inode(struct task_struct *p,
                                  struct inode *inode)
  {
 -      struct inode_security_struct *isec = inode->i_security;
 +      struct inode_security_struct *isec = selinux_inode(inode);
        u32 sid = task_sid(p);
  
        spin_lock(&isec->lock);
@@@ -4276,7 -4335,7 +4276,7 @@@ static int sock_has_perm(struct sock *s
  static int selinux_socket_create(int family, int type,
                                 int protocol, int kern)
  {
 -      const struct task_security_struct *tsec = current_security();
 +      const struct task_security_struct *tsec = selinux_cred(current_cred());
        u32 newsid;
        u16 secclass;
        int rc;
  static int selinux_socket_post_create(struct socket *sock, int family,
                                      int type, int protocol, int kern)
  {
 -      const struct task_security_struct *tsec = current_security();
 +      const struct task_security_struct *tsec = selinux_cred(current_cred());
        struct inode_security_struct *isec = inode_security_novalidate(SOCK_INODE(sock));
        struct sk_security_struct *sksec;
        u16 sclass = socket_type_to_security_class(family, type, protocol);
@@@ -4472,7 -4531,7 +4472,7 @@@ err_af
  }
  
  /* This supports connect(2) and SCTP connect services such as sctp_connectx(3)
-  * and sctp_sendmsg(3) as described in Documentation/security/LSM-sctp.rst
+  * and sctp_sendmsg(3) as described in Documentation/security/SCTP.rst
   */
  static int selinux_socket_connect_helper(struct socket *sock,
                                         struct sockaddr *address, int addrlen)
@@@ -5177,7 -5236,7 +5177,7 @@@ static int selinux_secmark_relabel_pack
        const struct task_security_struct *__tsec;
        u32 tsid;
  
 -      __tsec = current_security();
 +      __tsec = selinux_cred(current_cred());
        tsid = __tsec->sid;
  
        return avc_has_perm(&selinux_state,
@@@ -5652,22 -5711,51 +5652,22 @@@ static int selinux_netlink_send(struct 
        return selinux_nlmsg_perm(sk, skb);
  }
  
 -static int ipc_alloc_security(struct kern_ipc_perm *perm,
 -                            u16 sclass)
 +static void ipc_init_security(struct ipc_security_struct *isec, u16 sclass)
  {
 -      struct ipc_security_struct *isec;
 -
 -      isec = kzalloc(sizeof(struct ipc_security_struct), GFP_KERNEL);
 -      if (!isec)
 -              return -ENOMEM;
 -
        isec->sclass = sclass;
        isec->sid = current_sid();
 -      perm->security = isec;
 -
 -      return 0;
 -}
 -
 -static void ipc_free_security(struct kern_ipc_perm *perm)
 -{
 -      struct ipc_security_struct *isec = perm->security;
 -      perm->security = NULL;
 -      kfree(isec);
  }
  
  static int msg_msg_alloc_security(struct msg_msg *msg)
  {
        struct msg_security_struct *msec;
  
 -      msec = kzalloc(sizeof(struct msg_security_struct), GFP_KERNEL);
 -      if (!msec)
 -              return -ENOMEM;
 -
 +      msec = selinux_msg_msg(msg);
        msec->sid = SECINITSID_UNLABELED;
 -      msg->security = msec;
  
        return 0;
  }
  
 -static void msg_msg_free_security(struct msg_msg *msg)
 -{
 -      struct msg_security_struct *msec = msg->security;
 -
 -      msg->security = NULL;
 -      kfree(msec);
 -}
 -
  static int ipc_has_perm(struct kern_ipc_perm *ipc_perms,
                        u32 perms)
  {
        struct common_audit_data ad;
        u32 sid = current_sid();
  
 -      isec = ipc_perms->security;
 +      isec = selinux_ipc(ipc_perms);
  
        ad.type = LSM_AUDIT_DATA_IPC;
        ad.u.ipc_id = ipc_perms->key;
@@@ -5689,6 -5777,11 +5689,6 @@@ static int selinux_msg_msg_alloc_securi
        return msg_msg_alloc_security(msg);
  }
  
 -static void selinux_msg_msg_free_security(struct msg_msg *msg)
 -{
 -      msg_msg_free_security(msg);
 -}
 -
  /* message queue security operations */
  static int selinux_msg_queue_alloc_security(struct kern_ipc_perm *msq)
  {
        u32 sid = current_sid();
        int rc;
  
 -      rc = ipc_alloc_security(msq, SECCLASS_MSGQ);
 -      if (rc)
 -              return rc;
 -
 -      isec = msq->security;
 +      isec = selinux_ipc(msq);
 +      ipc_init_security(isec, SECCLASS_MSGQ);
  
        ad.type = LSM_AUDIT_DATA_IPC;
        ad.u.ipc_id = msq->key;
        rc = avc_has_perm(&selinux_state,
                          sid, isec->sid, SECCLASS_MSGQ,
                          MSGQ__CREATE, &ad);
 -      if (rc) {
 -              ipc_free_security(msq);
 -              return rc;
 -      }
 -      return 0;
 -}
 -
 -static void selinux_msg_queue_free_security(struct kern_ipc_perm *msq)
 -{
 -      ipc_free_security(msq);
 +      return rc;
  }
  
  static int selinux_msg_queue_associate(struct kern_ipc_perm *msq, int msqflg)
        struct common_audit_data ad;
        u32 sid = current_sid();
  
 -      isec = msq->security;
 +      isec = selinux_ipc(msq);
  
        ad.type = LSM_AUDIT_DATA_IPC;
        ad.u.ipc_id = msq->key;
@@@ -5764,8 -5869,8 +5764,8 @@@ static int selinux_msg_queue_msgsnd(str
        u32 sid = current_sid();
        int rc;
  
 -      isec = msq->security;
 -      msec = msg->security;
 +      isec = selinux_ipc(msq);
 +      msec = selinux_msg_msg(msg);
  
        /*
         * First time through, need to assign label to the message
@@@ -5812,8 -5917,8 +5812,8 @@@ static int selinux_msg_queue_msgrcv(str
        u32 sid = task_sid(target);
        int rc;
  
 -      isec = msq->security;
 -      msec = msg->security;
 +      isec = selinux_ipc(msq);
 +      msec = selinux_msg_msg(msg);
  
        ad.type = LSM_AUDIT_DATA_IPC;
        ad.u.ipc_id = msq->key;
@@@ -5836,8 -5941,11 +5836,8 @@@ static int selinux_shm_alloc_security(s
        u32 sid = current_sid();
        int rc;
  
 -      rc = ipc_alloc_security(shp, SECCLASS_SHM);
 -      if (rc)
 -              return rc;
 -
 -      isec = shp->security;
 +      isec = selinux_ipc(shp);
 +      ipc_init_security(isec, SECCLASS_SHM);
  
        ad.type = LSM_AUDIT_DATA_IPC;
        ad.u.ipc_id = shp->key;
        rc = avc_has_perm(&selinux_state,
                          sid, isec->sid, SECCLASS_SHM,
                          SHM__CREATE, &ad);
 -      if (rc) {
 -              ipc_free_security(shp);
 -              return rc;
 -      }
 -      return 0;
 -}
 -
 -static void selinux_shm_free_security(struct kern_ipc_perm *shp)
 -{
 -      ipc_free_security(shp);
 +      return rc;
  }
  
  static int selinux_shm_associate(struct kern_ipc_perm *shp, int shmflg)
        struct common_audit_data ad;
        u32 sid = current_sid();
  
 -      isec = shp->security;
 +      isec = selinux_ipc(shp);
  
        ad.type = LSM_AUDIT_DATA_IPC;
        ad.u.ipc_id = shp->key;
@@@ -5921,8 -6038,11 +5921,8 @@@ static int selinux_sem_alloc_security(s
        u32 sid = current_sid();
        int rc;
  
 -      rc = ipc_alloc_security(sma, SECCLASS_SEM);
 -      if (rc)
 -              return rc;
 -
 -      isec = sma->security;
 +      isec = selinux_ipc(sma);
 +      ipc_init_security(isec, SECCLASS_SEM);
  
        ad.type = LSM_AUDIT_DATA_IPC;
        ad.u.ipc_id = sma->key;
        rc = avc_has_perm(&selinux_state,
                          sid, isec->sid, SECCLASS_SEM,
                          SEM__CREATE, &ad);
 -      if (rc) {
 -              ipc_free_security(sma);
 -              return rc;
 -      }
 -      return 0;
 -}
 -
 -static void selinux_sem_free_security(struct kern_ipc_perm *sma)
 -{
 -      ipc_free_security(sma);
 +      return rc;
  }
  
  static int selinux_sem_associate(struct kern_ipc_perm *sma, int semflg)
        struct common_audit_data ad;
        u32 sid = current_sid();
  
 -      isec = sma->security;
 +      isec = selinux_ipc(sma);
  
        ad.type = LSM_AUDIT_DATA_IPC;
        ad.u.ipc_id = sma->key;
@@@ -6025,7 -6154,7 +6025,7 @@@ static int selinux_ipc_permission(struc
  
  static void selinux_ipc_getsecid(struct kern_ipc_perm *ipcp, u32 *secid)
  {
 -      struct ipc_security_struct *isec = ipcp->security;
 +      struct ipc_security_struct *isec = selinux_ipc(ipcp);
        *secid = isec->sid;
  }
  
@@@ -6044,7 -6173,7 +6044,7 @@@ static int selinux_getprocattr(struct t
        unsigned len;
  
        rcu_read_lock();
 -      __tsec = __task_cred(p)->security;
 +      __tsec = selinux_cred(__task_cred(p));
  
        if (current != p) {
                error = avc_has_perm(&selinux_state,
@@@ -6167,7 -6296,7 +6167,7 @@@ static int selinux_setprocattr(const ch
           operation.  See selinux_bprm_set_creds for the execve
           checks and may_create for the file creation checks. The
           operation will then fail if the context is not permitted. */
 -      tsec = new->security;
 +      tsec = selinux_cred(new);
        if (!strcmp(name, "exec")) {
                tsec->exec_sid = sid;
        } else if (!strcmp(name, "fscreate")) {
@@@ -6251,7 -6380,7 +6251,7 @@@ static void selinux_release_secctx(cha
  
  static void selinux_inode_invalidate_secctx(struct inode *inode)
  {
 -      struct inode_security_struct *isec = inode->i_security;
 +      struct inode_security_struct *isec = selinux_inode(inode);
  
        spin_lock(&isec->lock);
        isec->initialized = LABEL_INVALID;
   */
  static int selinux_inode_notifysecctx(struct inode *inode, void *ctx, u32 ctxlen)
  {
 -      return selinux_inode_setsecurity(inode, XATTR_SELINUX_SUFFIX, ctx, ctxlen, 0);
 +      int rc = selinux_inode_setsecurity(inode, XATTR_SELINUX_SUFFIX,
 +                                         ctx, ctxlen, 0);
 +      /* Do not return error when suppressing label (SBLABEL_MNT not set). */
 +      return rc == -EOPNOTSUPP ? 0 : rc;
  }
  
  /*
@@@ -6299,7 -6425,7 +6299,7 @@@ static int selinux_key_alloc(struct ke
        if (!ksec)
                return -ENOMEM;
  
 -      tsec = cred->security;
 +      tsec = selinux_cred(cred);
        if (tsec->keycreate_sid)
                ksec->sid = tsec->keycreate_sid;
        else
@@@ -6562,14 -6688,6 +6562,14 @@@ static void selinux_bpf_prog_free(struc
  }
  #endif
  
 +struct lsm_blob_sizes selinux_blob_sizes __lsm_ro_after_init = {
 +      .lbs_cred = sizeof(struct task_security_struct),
 +      .lbs_file = sizeof(struct file_security_struct),
 +      .lbs_inode = sizeof(struct inode_security_struct),
 +      .lbs_ipc = sizeof(struct ipc_security_struct),
 +      .lbs_msg_msg = sizeof(struct msg_security_struct),
 +};
 +
  static struct security_hook_list selinux_hooks[] __lsm_ro_after_init = {
        LSM_HOOK_INIT(binder_set_context_mgr, selinux_binder_set_context_mgr),
        LSM_HOOK_INIT(binder_transaction, selinux_binder_transaction),
  
        LSM_HOOK_INIT(file_permission, selinux_file_permission),
        LSM_HOOK_INIT(file_alloc_security, selinux_file_alloc_security),
 -      LSM_HOOK_INIT(file_free_security, selinux_file_free_security),
        LSM_HOOK_INIT(file_ioctl, selinux_file_ioctl),
        LSM_HOOK_INIT(mmap_file, selinux_mmap_file),
        LSM_HOOK_INIT(mmap_addr, selinux_mmap_addr),
        LSM_HOOK_INIT(file_open, selinux_file_open),
  
        LSM_HOOK_INIT(task_alloc, selinux_task_alloc),
 -      LSM_HOOK_INIT(cred_alloc_blank, selinux_cred_alloc_blank),
 -      LSM_HOOK_INIT(cred_free, selinux_cred_free),
        LSM_HOOK_INIT(cred_prepare, selinux_cred_prepare),
        LSM_HOOK_INIT(cred_transfer, selinux_cred_transfer),
        LSM_HOOK_INIT(cred_getsecid, selinux_cred_getsecid),
        LSM_HOOK_INIT(ipc_getsecid, selinux_ipc_getsecid),
  
        LSM_HOOK_INIT(msg_msg_alloc_security, selinux_msg_msg_alloc_security),
 -      LSM_HOOK_INIT(msg_msg_free_security, selinux_msg_msg_free_security),
  
        LSM_HOOK_INIT(msg_queue_alloc_security,
                        selinux_msg_queue_alloc_security),
 -      LSM_HOOK_INIT(msg_queue_free_security, selinux_msg_queue_free_security),
        LSM_HOOK_INIT(msg_queue_associate, selinux_msg_queue_associate),
        LSM_HOOK_INIT(msg_queue_msgctl, selinux_msg_queue_msgctl),
        LSM_HOOK_INIT(msg_queue_msgsnd, selinux_msg_queue_msgsnd),
        LSM_HOOK_INIT(msg_queue_msgrcv, selinux_msg_queue_msgrcv),
  
        LSM_HOOK_INIT(shm_alloc_security, selinux_shm_alloc_security),
 -      LSM_HOOK_INIT(shm_free_security, selinux_shm_free_security),
        LSM_HOOK_INIT(shm_associate, selinux_shm_associate),
        LSM_HOOK_INIT(shm_shmctl, selinux_shm_shmctl),
        LSM_HOOK_INIT(shm_shmat, selinux_shm_shmat),
  
        LSM_HOOK_INIT(sem_alloc_security, selinux_sem_alloc_security),
 -      LSM_HOOK_INIT(sem_free_security, selinux_sem_free_security),
        LSM_HOOK_INIT(sem_associate, selinux_sem_associate),
        LSM_HOOK_INIT(sem_semctl, selinux_sem_semctl),
        LSM_HOOK_INIT(sem_semop, selinux_sem_semop),
  
  static __init int selinux_init(void)
  {
 -      if (!security_module_enable("selinux")) {
 -              selinux_enabled = 0;
 -              return 0;
 -      }
 -
 -      if (!selinux_enabled) {
 -              pr_info("SELinux:  Disabled at boot.\n");
 -              return 0;
 -      }
 -
        pr_info("SELinux:  Initializing.\n");
  
        memset(&selinux_state, 0, sizeof(selinux_state));
  
        default_noexec = !(VM_DATA_DEFAULT_FLAGS & VM_EXEC);
  
 -      sel_inode_cache = kmem_cache_create("selinux_inode_security",
 -                                          sizeof(struct inode_security_struct),
 -                                          0, SLAB_PANIC, NULL);
 -      file_security_cache = kmem_cache_create("selinux_file_security",
 -                                          sizeof(struct file_security_struct),
 -                                          0, SLAB_PANIC, NULL);
        avc_init();
  
        avtab_cache_init();
@@@ -6858,9 -6999,6 +6858,9 @@@ void selinux_complete_init(void
     all processes and objects when they are created. */
  DEFINE_LSM(selinux) = {
        .name = "selinux",
 +      .flags = LSM_FLAG_LEGACY_MAJOR | LSM_FLAG_EXCLUSIVE,
 +      .enabled = &selinux_enabled,
 +      .blobs = &selinux_blob_sizes,
        .init = selinux_init,
  };