forked from Minki/linux
Merge branch 'akpm' (patches from Andrew)
Merge yet more updates from Andrew Morton:
- the rest of MM
- various misc fixes and tweaks
* emailed patches from Andrew Morton <akpm@linux-foundation.org>: (22 commits)
mm: Change return type int to vm_fault_t for fault handlers
lib/fonts: convert comments to utf-8
s390: ebcdic: convert comments to UTF-8
treewide: convert ISO_8859-1 text comments to utf-8
drivers/gpu/drm/gma500/: change return type to vm_fault_t
docs/core-api: mm-api: add section about GFP flags
docs/mm: make GFP flags descriptions usable as kernel-doc
docs/core-api: split memory management API to a separate file
docs/core-api: move *{str,mem}dup* to "String Manipulation"
docs/core-api: kill trailing whitespace in kernel-api.rst
mm/util: add kernel-doc for kvfree
mm/util: make strndup_user description a kernel-doc comment
fs/proc/vmcore.c: hide vmcoredd_mmap_dumps() for nommu builds
treewide: correct "differenciate" and "instanciate" typos
fs/afs: use new return type vm_fault_t
drivers/hwtracing/intel_th/msu.c: change return type to vm_fault_t
mm: soft-offline: close the race against page allocation
mm: fix race on soft-offlining free huge pages
namei: allow restricted O_CREAT of FIFOs and regular files
hfs: prevent crash on exit from failed search
...
This commit is contained in:
Linus Torvalds
commit
33e17876ea
@ -27,6 +27,7 @@ Core utilities
|
||||
errseq
|
||||
printk-formats
|
||||
circular-buffers
|
||||
mm-api
|
||||
gfp_mask-from-fs-io
|
||||
timekeeping
|
||||
boot-time-mm
|
||||
|
||||
@ -39,6 +39,10 @@ String Manipulation
|
||||
.. kernel-doc:: lib/string.c
|
||||
:export:
|
||||
|
||||
.. kernel-doc:: mm/util.c
|
||||
:functions: kstrdup kstrdup_const kstrndup kmemdup kmemdup_nul memdup_user
|
||||
vmemdup_user strndup_user memdup_user_nul
|
||||
|
||||
Basic Kernel Library Functions
|
||||
==============================
|
||||
|
||||
@ -155,60 +159,6 @@ UUID/GUID
|
||||
.. kernel-doc:: lib/uuid.c
|
||||
:export:
|
||||
|
||||
Memory Management in Linux
|
||||
==========================
|
||||
|
||||
The Slab Cache
|
||||
--------------
|
||||
|
||||
.. kernel-doc:: include/linux/slab.h
|
||||
:internal:
|
||||
|
||||
.. kernel-doc:: mm/slab.c
|
||||
:export:
|
||||
|
||||
.. kernel-doc:: mm/util.c
|
||||
:export:
|
||||
|
||||
User Space Memory Access
|
||||
------------------------
|
||||
|
||||
.. kernel-doc:: arch/x86/include/asm/uaccess.h
|
||||
:internal:
|
||||
|
||||
.. kernel-doc:: arch/x86/lib/usercopy_32.c
|
||||
:export:
|
||||
|
||||
More Memory Management Functions
|
||||
--------------------------------
|
||||
|
||||
.. kernel-doc:: mm/readahead.c
|
||||
:export:
|
||||
|
||||
.. kernel-doc:: mm/filemap.c
|
||||
:export:
|
||||
|
||||
.. kernel-doc:: mm/memory.c
|
||||
:export:
|
||||
|
||||
.. kernel-doc:: mm/vmalloc.c
|
||||
:export:
|
||||
|
||||
.. kernel-doc:: mm/page_alloc.c
|
||||
:internal:
|
||||
|
||||
.. kernel-doc:: mm/mempool.c
|
||||
:export:
|
||||
|
||||
.. kernel-doc:: mm/dmapool.c
|
||||
:export:
|
||||
|
||||
.. kernel-doc:: mm/page-writeback.c
|
||||
:export:
|
||||
|
||||
.. kernel-doc:: mm/truncate.c
|
||||
:export:
|
||||
|
||||
Kernel IPC facilities
|
||||
=====================
|
||||
|
||||
@ -437,4 +387,3 @@ Read-Copy Update (RCU)
|
||||
.. kernel-doc:: include/linux/rcu_sync.h
|
||||
|
||||
.. kernel-doc:: kernel/rcu/sync.c
|
||||
|
||||
|
||||
78
Documentation/core-api/mm-api.rst
Normal file
78
Documentation/core-api/mm-api.rst
Normal file
@ -0,0 +1,78 @@
|
||||
======================
|
||||
Memory Management APIs
|
||||
======================
|
||||
|
||||
User Space Memory Access
|
||||
========================
|
||||
|
||||
.. kernel-doc:: arch/x86/include/asm/uaccess.h
|
||||
:internal:
|
||||
|
||||
.. kernel-doc:: arch/x86/lib/usercopy_32.c
|
||||
:export:
|
||||
|
||||
.. kernel-doc:: mm/util.c
|
||||
:functions: get_user_pages_fast
|
||||
|
||||
Memory Allocation Controls
|
||||
==========================
|
||||
|
||||
Functions which need to allocate memory often use GFP flags to express
|
||||
how that memory should be allocated. The GFP acronym stands for "get
|
||||
free pages", the underlying memory allocation function. Not every GFP
|
||||
flag is allowed to every function which may allocate memory. Most
|
||||
users will want to use a plain ``GFP_KERNEL``.
|
||||
|
||||
.. kernel-doc:: include/linux/gfp.h
|
||||
:doc: Page mobility and placement hints
|
||||
|
||||
.. kernel-doc:: include/linux/gfp.h
|
||||
:doc: Watermark modifiers
|
||||
|
||||
.. kernel-doc:: include/linux/gfp.h
|
||||
:doc: Reclaim modifiers
|
||||
|
||||
.. kernel-doc:: include/linux/gfp.h
|
||||
:doc: Common combinations
|
||||
|
||||
The Slab Cache
|
||||
==============
|
||||
|
||||
.. kernel-doc:: include/linux/slab.h
|
||||
:internal:
|
||||
|
||||
.. kernel-doc:: mm/slab.c
|
||||
:export:
|
||||
|
||||
.. kernel-doc:: mm/util.c
|
||||
:functions: kfree_const kvmalloc_node kvfree
|
||||
|
||||
More Memory Management Functions
|
||||
================================
|
||||
|
||||
.. kernel-doc:: mm/readahead.c
|
||||
:export:
|
||||
|
||||
.. kernel-doc:: mm/filemap.c
|
||||
:export:
|
||||
|
||||
.. kernel-doc:: mm/memory.c
|
||||
:export:
|
||||
|
||||
.. kernel-doc:: mm/vmalloc.c
|
||||
:export:
|
||||
|
||||
.. kernel-doc:: mm/page_alloc.c
|
||||
:internal:
|
||||
|
||||
.. kernel-doc:: mm/mempool.c
|
||||
:export:
|
||||
|
||||
.. kernel-doc:: mm/dmapool.c
|
||||
:export:
|
||||
|
||||
.. kernel-doc:: mm/page-writeback.c
|
||||
:export:
|
||||
|
||||
.. kernel-doc:: mm/truncate.c
|
||||
:export:
|
||||
@ -2,7 +2,7 @@
|
||||
|
||||
Required properties:
|
||||
- compatible: Should be "nxp,pn544-i2c".
|
||||
- clock-frequency: I²C work frequency.
|
||||
- clock-frequency: I²C work frequency.
|
||||
- reg: address on the bus
|
||||
- interrupts: GPIO interrupt to which the chip is connected
|
||||
- enable-gpios: Output GPIO pin used for enabling/disabling the PN544
|
||||
|
||||
@ -49,7 +49,7 @@ compatible (optional) - standard definition
|
||||
- may contain the following strings:
|
||||
- shared-dma-pool: This indicates a region of memory meant to be
|
||||
used as a shared pool of DMA buffers for a set of devices. It can
|
||||
be used by an operating system to instanciate the necessary pool
|
||||
be used by an operating system to instantiate the necessary pool
|
||||
management subsystem if necessary.
|
||||
- vendor specific string in the form <vendor>,[<device>-]<usage>
|
||||
no-map (optional) - empty property
|
||||
|
||||
@ -34,7 +34,9 @@ Currently, these files are in /proc/sys/fs:
|
||||
- overflowgid
|
||||
- pipe-user-pages-hard
|
||||
- pipe-user-pages-soft
|
||||
- protected_fifos
|
||||
- protected_hardlinks
|
||||
- protected_regular
|
||||
- protected_symlinks
|
||||
- suid_dumpable
|
||||
- super-max
|
||||
@ -182,6 +184,24 @@ applied.
|
||||
|
||||
==============================================================
|
||||
|
||||
protected_fifos:
|
||||
|
||||
The intent of this protection is to avoid unintentional writes to
|
||||
an attacker-controlled FIFO, where a program expected to create a regular
|
||||
file.
|
||||
|
||||
When set to "0", writing to FIFOs is unrestricted.
|
||||
|
||||
When set to "1" don't allow O_CREAT open on FIFOs that we don't own
|
||||
in world writable sticky directories, unless they are owned by the
|
||||
owner of the directory.
|
||||
|
||||
When set to "2" it also applies to group writable sticky directories.
|
||||
|
||||
This protection is based on the restrictions in Openwall.
|
||||
|
||||
==============================================================
|
||||
|
||||
protected_hardlinks:
|
||||
|
||||
A long-standing class of security issues is the hardlink-based
|
||||
@ -202,6 +222,22 @@ This protection is based on the restrictions in Openwall and grsecurity.
|
||||
|
||||
==============================================================
|
||||
|
||||
protected_regular:
|
||||
|
||||
This protection is similar to protected_fifos, but it
|
||||
avoids writes to an attacker-controlled regular file, where a program
|
||||
expected to create one.
|
||||
|
||||
When set to "0", writing to regular files is unrestricted.
|
||||
|
||||
When set to "1" don't allow O_CREAT open on regular files that we
|
||||
don't own in world writable sticky directories, unless they are
|
||||
owned by the owner of the directory.
|
||||
|
||||
When set to "2" it also applies to group writable sticky directories.
|
||||
|
||||
==============================================================
|
||||
|
||||
protected_symlinks:
|
||||
|
||||
A long-standing class of security issues is the symlink-based
|
||||
|
||||
@ -1,7 +1,7 @@
|
||||
/*
|
||||
* Copyright 2014 Open Source Support GmbH
|
||||
*
|
||||
* David Lanzendörfer <david.lanzendoerfer@o2s.ch>
|
||||
* David Lanzendörfer <david.lanzendoerfer@o2s.ch>
|
||||
*
|
||||
* This file is dual-licensed: you can use it either under the terms
|
||||
* of the GPL or the X11 license, at your option. Note that this dual
|
||||
|
||||
@ -2,7 +2,7 @@
|
||||
* Glue code for the SHA256 Secure Hash Algorithm assembly implementation
|
||||
* using optimized ARM assembler and NEON instructions.
|
||||
*
|
||||
* Copyright © 2015 Google Inc.
|
||||
* Copyright © 2015 Google Inc.
|
||||
*
|
||||
* This file is based on sha256_ssse3_glue.c:
|
||||
* Copyright (C) 2013 Intel Corporation
|
||||
|
||||
@ -2,10 +2,10 @@
|
||||
* Glue code for the SHA256 Secure Hash Algorithm assembly implementation
|
||||
* using NEON instructions.
|
||||
*
|
||||
* Copyright © 2015 Google Inc.
|
||||
* Copyright © 2015 Google Inc.
|
||||
*
|
||||
* This file is based on sha512_neon_glue.c:
|
||||
* Copyright © 2014 Jussi Kivilinna <jussi.kivilinna@iki.fi>
|
||||
* Copyright © 2014 Jussi Kivilinna <jussi.kivilinna@iki.fi>
|
||||
*
|
||||
* This program is free software; you can redistribute it and/or modify it
|
||||
* under the terms of the GNU General Public License as published by the Free
|
||||
|
||||
@ -514,7 +514,7 @@ static void kvmppc_set_msr_pr(struct kvm_vcpu *vcpu, u64 msr)
|
||||
/*
|
||||
* When switching from 32 to 64-bit, we may have a stale 32-bit
|
||||
* magic page around, we need to flush it. Typically 32-bit magic
|
||||
* page will be instanciated when calling into RTAS. Note: We
|
||||
* page will be instantiated when calling into RTAS. Note: We
|
||||
* assume that such transition only happens while in kernel mode,
|
||||
* ie, we never transition from user 32-bit to kernel 64-bit with
|
||||
* a 32-bit magic page around.
|
||||
|
||||
@ -38,7 +38,7 @@
|
||||
* Virtual mode variants of the hcalls for use on radix/radix
|
||||
* with AIL. They require the VCPU's VP to be "pushed"
|
||||
*
|
||||
* We still instanciate them here because we use some of the
|
||||
* We still instantiate them here because we use some of the
|
||||
* generated utility functions as well in this file.
|
||||
*/
|
||||
#define XIVE_RUNTIME_CHECKS
|
||||
|
||||
@ -1192,7 +1192,7 @@ static void pmac_i2c_devscan(void (*callback)(struct device_node *dev,
|
||||
{ NULL, NULL, 0 },
|
||||
};
|
||||
|
||||
/* Only some devices need to have platform functions instanciated
|
||||
/* Only some devices need to have platform functions instantiated
|
||||
* here. For now, we have a table. Others, like 9554 i2c GPIOs used
|
||||
* on Xserve, if we ever do a driver for them, will use their own
|
||||
* platform function instance
|
||||
|
||||
@ -266,7 +266,7 @@ static unsigned int xive_get_irq(void)
|
||||
* of pending priorities. This will also have the effect of
|
||||
* updating the CPPR to the most favored pending interrupts.
|
||||
*
|
||||
* In the future, if we have a way to differenciate a first
|
||||
* In the future, if we have a way to differentiate a first
|
||||
* entry (on HW interrupt) from a replay triggered by EOI,
|
||||
* we could skip this on replays unless we soft-mask tells us
|
||||
* that a new HW interrupt occurred.
|
||||
|
||||
@ -111,15 +111,15 @@ __u8 _ebcasc[256] =
|
||||
0x07, 0x07, 0x16, 0x07, 0x07, 0x07, 0x07, 0x04,
|
||||
/* 0x38 -SBS -IT -RFF -CU3 DC4 NAK ---- SUB */
|
||||
0x07, 0x07, 0x07, 0x07, 0x14, 0x15, 0x07, 0x1A,
|
||||
/* 0x40 SP RSP <EFBFBD>ä ---- */
|
||||
/* 0x40 SP RSP ä ---- */
|
||||
0x20, 0xFF, 0x83, 0x84, 0x85, 0xA0, 0x07, 0x86,
|
||||
/* 0x48 . < ( + | */
|
||||
0x87, 0xA4, 0x9B, 0x2E, 0x3C, 0x28, 0x2B, 0x7C,
|
||||
/* 0x50 & ---- */
|
||||
0x26, 0x82, 0x88, 0x89, 0x8A, 0xA1, 0x8C, 0x07,
|
||||
/* 0x58 <EFBFBD>ß ! $ * ) ; */
|
||||
/* 0x58 ß ! $ * ) ; */
|
||||
0x8D, 0xE1, 0x21, 0x24, 0x2A, 0x29, 0x3B, 0xAA,
|
||||
/* 0x60 - / ---- <EFBFBD>Ä ---- ---- ---- */
|
||||
/* 0x60 - / ---- Ä ---- ---- ---- */
|
||||
0x2D, 0x2F, 0x07, 0x8E, 0x07, 0x07, 0x07, 0x8F,
|
||||
/* 0x68 ---- , % _ > ? */
|
||||
0x80, 0xA5, 0x07, 0x2C, 0x25, 0x5F, 0x3E, 0x3F,
|
||||
@ -131,7 +131,7 @@ __u8 _ebcasc[256] =
|
||||
0x07, 0x61, 0x62, 0x63, 0x64, 0x65, 0x66, 0x67,
|
||||
/* 0x88 h i ---- ---- ---- */
|
||||
0x68, 0x69, 0xAE, 0xAF, 0x07, 0x07, 0x07, 0xF1,
|
||||
/* 0x90 <EFBFBD>° j k l m n o p */
|
||||
/* 0x90 ° j k l m n o p */
|
||||
0xF8, 0x6A, 0x6B, 0x6C, 0x6D, 0x6E, 0x6F, 0x70,
|
||||
/* 0x98 q r ---- ---- */
|
||||
0x71, 0x72, 0xA6, 0xA7, 0x91, 0x07, 0x92, 0x07,
|
||||
@ -139,25 +139,25 @@ __u8 _ebcasc[256] =
|
||||
0xE6, 0x7E, 0x73, 0x74, 0x75, 0x76, 0x77, 0x78,
|
||||
/* 0xA8 y z ---- ---- ---- ---- */
|
||||
0x79, 0x7A, 0xAD, 0xAB, 0x07, 0x07, 0x07, 0x07,
|
||||
/* 0xB0 ^ ---- <EFBFBD>§ ---- */
|
||||
/* 0xB0 ^ ---- § ---- */
|
||||
0x5E, 0x9C, 0x9D, 0xFA, 0x07, 0x07, 0x07, 0xAC,
|
||||
/* 0xB8 ---- [ ] ---- ---- ---- ---- */
|
||||
0xAB, 0x07, 0x5B, 0x5D, 0x07, 0x07, 0x07, 0x07,
|
||||
/* 0xC0 { A B C D E F G */
|
||||
0x7B, 0x41, 0x42, 0x43, 0x44, 0x45, 0x46, 0x47,
|
||||
/* 0xC8 H I ---- <EFBFBD>ö ---- */
|
||||
/* 0xC8 H I ---- ö ---- */
|
||||
0x48, 0x49, 0x07, 0x93, 0x94, 0x95, 0xA2, 0x07,
|
||||
/* 0xD0 } J K L M N O P */
|
||||
0x7D, 0x4A, 0x4B, 0x4C, 0x4D, 0x4E, 0x4F, 0x50,
|
||||
/* 0xD8 Q R ---- <EFBFBD>ü */
|
||||
/* 0xD8 Q R ---- ü */
|
||||
0x51, 0x52, 0x07, 0x96, 0x81, 0x97, 0xA3, 0x98,
|
||||
/* 0xE0 \ S T U V W X */
|
||||
0x5C, 0xF6, 0x53, 0x54, 0x55, 0x56, 0x57, 0x58,
|
||||
/* 0xE8 Y Z ---- <EFBFBD>Ö ---- ---- ---- */
|
||||
/* 0xE8 Y Z ---- Ö ---- ---- ---- */
|
||||
0x59, 0x5A, 0xFD, 0x07, 0x99, 0x07, 0x07, 0x07,
|
||||
/* 0xF0 0 1 2 3 4 5 6 7 */
|
||||
0x30, 0x31, 0x32, 0x33, 0x34, 0x35, 0x36, 0x37,
|
||||
/* 0xF8 8 9 ---- ---- <EFBFBD>Ü ---- ---- ---- */
|
||||
/* 0xF8 8 9 ---- ---- Ü ---- ---- ---- */
|
||||
0x38, 0x39, 0x07, 0x07, 0x9A, 0x07, 0x07, 0x07
|
||||
};
|
||||
|
||||
@ -260,15 +260,15 @@ __u8 _ebcasc_500[256] =
|
||||
0x07, 0x07, 0x16, 0x07, 0x07, 0x07, 0x07, 0x04,
|
||||
/* 0x38 -SBS -IT -RFF -CU3 DC4 NAK ---- SUB */
|
||||
0x07, 0x07, 0x07, 0x07, 0x14, 0x15, 0x07, 0x1A,
|
||||
/* 0x40 SP RSP <EFBFBD>ä ---- */
|
||||
/* 0x40 SP RSP ä ---- */
|
||||
0x20, 0xFF, 0x83, 0x84, 0x85, 0xA0, 0x07, 0x86,
|
||||
/* 0x48 [ . < ( + ! */
|
||||
0x87, 0xA4, 0x5B, 0x2E, 0x3C, 0x28, 0x2B, 0x21,
|
||||
/* 0x50 & ---- */
|
||||
0x26, 0x82, 0x88, 0x89, 0x8A, 0xA1, 0x8C, 0x07,
|
||||
/* 0x58 <EFBFBD>ß ] $ * ) ; ^ */
|
||||
/* 0x58 ß ] $ * ) ; ^ */
|
||||
0x8D, 0xE1, 0x5D, 0x24, 0x2A, 0x29, 0x3B, 0x5E,
|
||||
/* 0x60 - / ---- <EFBFBD>Ä ---- ---- ---- */
|
||||
/* 0x60 - / ---- Ä ---- ---- ---- */
|
||||
0x2D, 0x2F, 0x07, 0x8E, 0x07, 0x07, 0x07, 0x8F,
|
||||
/* 0x68 ---- , % _ > ? */
|
||||
0x80, 0xA5, 0x07, 0x2C, 0x25, 0x5F, 0x3E, 0x3F,
|
||||
@ -280,7 +280,7 @@ __u8 _ebcasc_500[256] =
|
||||
0x07, 0x61, 0x62, 0x63, 0x64, 0x65, 0x66, 0x67,
|
||||
/* 0x88 h i ---- ---- ---- */
|
||||
0x68, 0x69, 0xAE, 0xAF, 0x07, 0x07, 0x07, 0xF1,
|
||||
/* 0x90 <EFBFBD>° j k l m n o p */
|
||||
/* 0x90 ° j k l m n o p */
|
||||
0xF8, 0x6A, 0x6B, 0x6C, 0x6D, 0x6E, 0x6F, 0x70,
|
||||
/* 0x98 q r ---- ---- */
|
||||
0x71, 0x72, 0xA6, 0xA7, 0x91, 0x07, 0x92, 0x07,
|
||||
@ -288,25 +288,25 @@ __u8 _ebcasc_500[256] =
|
||||
0xE6, 0x7E, 0x73, 0x74, 0x75, 0x76, 0x77, 0x78,
|
||||
/* 0xA8 y z ---- ---- ---- ---- */
|
||||
0x79, 0x7A, 0xAD, 0xAB, 0x07, 0x07, 0x07, 0x07,
|
||||
/* 0xB0 ---- <EFBFBD>§ ---- */
|
||||
/* 0xB0 ---- § ---- */
|
||||
0x9B, 0x9C, 0x9D, 0xFA, 0x07, 0x07, 0x07, 0xAC,
|
||||
/* 0xB8 ---- | ---- ---- ---- ---- */
|
||||
0xAB, 0x07, 0xAA, 0x7C, 0x07, 0x07, 0x07, 0x07,
|
||||
/* 0xC0 { A B C D E F G */
|
||||
0x7B, 0x41, 0x42, 0x43, 0x44, 0x45, 0x46, 0x47,
|
||||
/* 0xC8 H I ---- <EFBFBD>ö ---- */
|
||||
/* 0xC8 H I ---- ö ---- */
|
||||
0x48, 0x49, 0x07, 0x93, 0x94, 0x95, 0xA2, 0x07,
|
||||
/* 0xD0 } J K L M N O P */
|
||||
0x7D, 0x4A, 0x4B, 0x4C, 0x4D, 0x4E, 0x4F, 0x50,
|
||||
/* 0xD8 Q R ---- <EFBFBD>ü */
|
||||
/* 0xD8 Q R ---- ü */
|
||||
0x51, 0x52, 0x07, 0x96, 0x81, 0x97, 0xA3, 0x98,
|
||||
/* 0xE0 \ S T U V W X */
|
||||
0x5C, 0xF6, 0x53, 0x54, 0x55, 0x56, 0x57, 0x58,
|
||||
/* 0xE8 Y Z ---- <EFBFBD>Ö ---- ---- ---- */
|
||||
/* 0xE8 Y Z ---- Ö ---- ---- ---- */
|
||||
0x59, 0x5A, 0xFD, 0x07, 0x99, 0x07, 0x07, 0x07,
|
||||
/* 0xF0 0 1 2 3 4 5 6 7 */
|
||||
0x30, 0x31, 0x32, 0x33, 0x34, 0x35, 0x36, 0x37,
|
||||
/* 0xF8 8 9 ---- ---- <EFBFBD>Ü ---- ---- ---- */
|
||||
/* 0xF8 8 9 ---- ---- Ü ---- ---- ---- */
|
||||
0x38, 0x39, 0x07, 0x07, 0x9A, 0x07, 0x07, 0x07
|
||||
};
|
||||
|
||||
|
||||
@ -129,9 +129,9 @@ $code=<<___;
|
||||
le?vperm $IN,$IN,$IN,$lemask
|
||||
vxor $zero,$zero,$zero
|
||||
|
||||
vpmsumd $Xl,$IN,$Hl # H.lo·Xi.lo
|
||||
vpmsumd $Xm,$IN,$H # H.hi·Xi.lo+H.lo·Xi.hi
|
||||
vpmsumd $Xh,$IN,$Hh # H.hi·Xi.hi
|
||||
vpmsumd $Xl,$IN,$Hl # H.lo·Xi.lo
|
||||
vpmsumd $Xm,$IN,$H # H.hi·Xi.lo+H.lo·Xi.hi
|
||||
vpmsumd $Xh,$IN,$Hh # H.hi·Xi.hi
|
||||
|
||||
vpmsumd $t2,$Xl,$xC2 # 1st phase
|
||||
|
||||
@ -187,11 +187,11 @@ $code=<<___;
|
||||
.align 5
|
||||
Loop:
|
||||
subic $len,$len,16
|
||||
vpmsumd $Xl,$IN,$Hl # H.lo·Xi.lo
|
||||
vpmsumd $Xl,$IN,$Hl # H.lo·Xi.lo
|
||||
subfe. r0,r0,r0 # borrow?-1:0
|
||||
vpmsumd $Xm,$IN,$H # H.hi·Xi.lo+H.lo·Xi.hi
|
||||
vpmsumd $Xm,$IN,$H # H.hi·Xi.lo+H.lo·Xi.hi
|
||||
and r0,r0,$len
|
||||
vpmsumd $Xh,$IN,$Hh # H.hi·Xi.hi
|
||||
vpmsumd $Xh,$IN,$Hh # H.hi·Xi.hi
|
||||
add $inp,$inp,r0
|
||||
|
||||
vpmsumd $t2,$Xl,$xC2 # 1st phase
|
||||
|
||||
@ -108,7 +108,7 @@ static int psbfb_pan(struct fb_var_screeninfo *var, struct fb_info *info)
|
||||
return 0;
|
||||
}
|
||||
|
||||
static int psbfb_vm_fault(struct vm_fault *vmf)
|
||||
static vm_fault_t psbfb_vm_fault(struct vm_fault *vmf)
|
||||
{
|
||||
struct vm_area_struct *vma = vmf->vma;
|
||||
struct psb_framebuffer *psbfb = vma->vm_private_data;
|
||||
@ -118,7 +118,7 @@ static int psbfb_vm_fault(struct vm_fault *vmf)
|
||||
int page_num;
|
||||
int i;
|
||||
unsigned long address;
|
||||
int ret;
|
||||
vm_fault_t ret = VM_FAULT_SIGBUS;
|
||||
unsigned long pfn;
|
||||
unsigned long phys_addr = (unsigned long)dev_priv->stolen_base +
|
||||
gtt->offset;
|
||||
@ -131,18 +131,14 @@ static int psbfb_vm_fault(struct vm_fault *vmf)
|
||||
for (i = 0; i < page_num; i++) {
|
||||
pfn = (phys_addr >> PAGE_SHIFT);
|
||||
|
||||
ret = vm_insert_mixed(vma, address,
|
||||
ret = vmf_insert_mixed(vma, address,
|
||||
__pfn_to_pfn_t(pfn, PFN_DEV));
|
||||
if (unlikely((ret == -EBUSY) || (ret != 0 && i > 0)))
|
||||
if (unlikely(ret & VM_FAULT_ERROR))
|
||||
break;
|
||||
else if (unlikely(ret != 0)) {
|
||||
ret = (ret == -ENOMEM) ? VM_FAULT_OOM : VM_FAULT_SIGBUS;
|
||||
return ret;
|
||||
}
|
||||
address += PAGE_SIZE;
|
||||
phys_addr += PAGE_SIZE;
|
||||
}
|
||||
return VM_FAULT_NOPAGE;
|
||||
return ret;
|
||||
}
|
||||
|
||||
static void psbfb_vm_open(struct vm_area_struct *vma)
|
||||
|
||||
@ -134,12 +134,13 @@ int psb_gem_dumb_create(struct drm_file *file, struct drm_device *dev,
|
||||
* vma->vm_private_data points to the GEM object that is backing this
|
||||
* mapping.
|
||||
*/
|
||||
int psb_gem_fault(struct vm_fault *vmf)
|
||||
vm_fault_t psb_gem_fault(struct vm_fault *vmf)
|
||||
{
|
||||
struct vm_area_struct *vma = vmf->vma;
|
||||
struct drm_gem_object *obj;
|
||||
struct gtt_range *r;
|
||||
int ret;
|
||||
int err;
|
||||
vm_fault_t ret;
|
||||
unsigned long pfn;
|
||||
pgoff_t page_offset;
|
||||
struct drm_device *dev;
|
||||
@ -158,9 +159,10 @@ int psb_gem_fault(struct vm_fault *vmf)
|
||||
/* For now the mmap pins the object and it stays pinned. As things
|
||||
stand that will do us no harm */
|
||||
if (r->mmapping == 0) {
|
||||
ret = psb_gtt_pin(r);
|
||||
if (ret < 0) {
|
||||
dev_err(dev->dev, "gma500: pin failed: %d\n", ret);
|
||||
err = psb_gtt_pin(r);
|
||||
if (err < 0) {
|
||||
dev_err(dev->dev, "gma500: pin failed: %d\n", err);
|
||||
ret = vmf_error(err);
|
||||
goto fail;
|
||||
}
|
||||
r->mmapping = 1;
|
||||
@ -175,18 +177,9 @@ int psb_gem_fault(struct vm_fault *vmf)
|
||||
pfn = (dev_priv->stolen_base + r->offset) >> PAGE_SHIFT;
|
||||
else
|
||||
pfn = page_to_pfn(r->pages[page_offset]);
|
||||
ret = vm_insert_pfn(vma, vmf->address, pfn);
|
||||
|
||||
ret = vmf_insert_pfn(vma, vmf->address, pfn);
|
||||
fail:
|
||||
mutex_unlock(&dev_priv->mmap_mutex);
|
||||
switch (ret) {
|
||||
case 0:
|
||||
case -ERESTARTSYS:
|
||||
case -EINTR:
|
||||
return VM_FAULT_NOPAGE;
|
||||
case -ENOMEM:
|
||||
return VM_FAULT_OOM;
|
||||
default:
|
||||
return VM_FAULT_SIGBUS;
|
||||
}
|
||||
|
||||
return ret;
|
||||
}
|
||||
|
||||
@ -21,6 +21,7 @@
|
||||
#define _PSB_DRV_H_
|
||||
|
||||
#include <linux/kref.h>
|
||||
#include <linux/mm_types.h>
|
||||
|
||||
#include <drm/drmP.h>
|
||||
#include <drm/drm_global.h>
|
||||
@ -749,7 +750,7 @@ extern int psb_gem_get_aperture(struct drm_device *dev, void *data,
|
||||
struct drm_file *file);
|
||||
extern int psb_gem_dumb_create(struct drm_file *file, struct drm_device *dev,
|
||||
struct drm_mode_create_dumb *args);
|
||||
extern int psb_gem_fault(struct vm_fault *vmf);
|
||||
extern vm_fault_t psb_gem_fault(struct vm_fault *vmf);
|
||||
|
||||
/* psb_device.c */
|
||||
extern const struct psb_ops psb_chip_ops;
|
||||
|
||||
@ -1182,7 +1182,7 @@ static void msc_mmap_close(struct vm_area_struct *vma)
|
||||
mutex_unlock(&msc->buf_mutex);
|
||||
}
|
||||
|
||||
static int msc_mmap_fault(struct vm_fault *vmf)
|
||||
static vm_fault_t msc_mmap_fault(struct vm_fault *vmf)
|
||||
{
|
||||
struct msc_iter *iter = vmf->vma->vm_file->private_data;
|
||||
struct msc *msc = iter->msc;
|
||||
|
||||
@ -1,7 +1,7 @@
|
||||
/*
|
||||
* LTC2632 Digital to analog convertors spi driver
|
||||
*
|
||||
* Copyright 2017 Maxime Roussin-Bélanger
|
||||
* Copyright 2017 Maxime Roussin-Bélanger
|
||||
* expanded by Silvan Murer <silvan.murer@gmail.com>
|
||||
*
|
||||
* Licensed under the GPL-2.
|
||||
|
||||
@ -2,7 +2,7 @@
|
||||
* LTC2952 (PowerPath) driver
|
||||
*
|
||||
* Copyright (C) 2014, Xsens Technologies BV <info@xsens.com>
|
||||
* Maintainer: René Moll <linux@r-moll.nl>
|
||||
* Maintainer: René Moll <linux@r-moll.nl>
|
||||
*
|
||||
* This program is free software; you can redistribute it and/or
|
||||
* modify it under the terms of the GNU General Public License
|
||||
@ -319,6 +319,6 @@ static struct platform_driver ltc2952_poweroff_driver = {
|
||||
|
||||
module_platform_driver(ltc2952_poweroff_driver);
|
||||
|
||||
MODULE_AUTHOR("René Moll <rene.moll@xsens.com>");
|
||||
MODULE_AUTHOR("René Moll <rene.moll@xsens.com>");
|
||||
MODULE_DESCRIPTION("LTC PowerPath power-off driver");
|
||||
MODULE_LICENSE("GPL v2");
|
||||
|
||||
@ -28,7 +28,7 @@
|
||||
* case of external interrupts without need for ack, clamping down
|
||||
* cpu in non-irq context does not reduce irq. for majority of the
|
||||
* cases, clamping down cpu does help reduce irq as well, we should
|
||||
* be able to differenciate the two cases and give a quantitative
|
||||
* be able to differentiate the two cases and give a quantitative
|
||||
* solution for the irqs that we can control. perhaps based on
|
||||
* get_cpu_iowait_time_us()
|
||||
*
|
||||
|
||||
@ -21,6 +21,7 @@
|
||||
#include <linux/fscache.h>
|
||||
#include <linux/backing-dev.h>
|
||||
#include <linux/uuid.h>
|
||||
#include <linux/mm_types.h>
|
||||
#include <net/net_namespace.h>
|
||||
#include <net/netns/generic.h>
|
||||
#include <net/sock.h>
|
||||
@ -1076,7 +1077,7 @@ extern int afs_writepages(struct address_space *, struct writeback_control *);
|
||||
extern void afs_pages_written_back(struct afs_vnode *, struct afs_call *);
|
||||
extern ssize_t afs_file_write(struct kiocb *, struct iov_iter *);
|
||||
extern int afs_fsync(struct file *, loff_t, loff_t, int);
|
||||
extern int afs_page_mkwrite(struct vm_fault *);
|
||||
extern vm_fault_t afs_page_mkwrite(struct vm_fault *vmf);
|
||||
extern void afs_prune_wb_keys(struct afs_vnode *);
|
||||
extern int afs_launder_page(struct page *);
|
||||
|
||||
|
||||
@ -753,7 +753,7 @@ int afs_fsync(struct file *file, loff_t start, loff_t end, int datasync)
|
||||
* notification that a previously read-only page is about to become writable
|
||||
* - if it returns an error, the caller will deliver a bus error signal
|
||||
*/
|
||||
int afs_page_mkwrite(struct vm_fault *vmf)
|
||||
vm_fault_t afs_page_mkwrite(struct vm_fault *vmf)
|
||||
{
|
||||
struct file *file = vmf->vma->vm_file;
|
||||
struct inode *inode = file_inode(file);
|
||||
|
||||
@ -75,9 +75,10 @@ int hfs_brec_insert(struct hfs_find_data *fd, void *entry, int entry_len)
|
||||
if (!fd->bnode) {
|
||||
if (!tree->root)
|
||||
hfs_btree_inc_height(tree);
|
||||
fd->bnode = hfs_bnode_find(tree, tree->leaf_head);
|
||||
if (IS_ERR(fd->bnode))
|
||||
return PTR_ERR(fd->bnode);
|
||||
node = hfs_bnode_find(tree, tree->leaf_head);
|
||||
if (IS_ERR(node))
|
||||
return PTR_ERR(node);
|
||||
fd->bnode = node;
|
||||
fd->record = -1;
|
||||
}
|
||||
new_node = NULL;
|
||||
|
||||
@ -73,9 +73,10 @@ int hfs_brec_insert(struct hfs_find_data *fd, void *entry, int entry_len)
|
||||
if (!fd->bnode) {
|
||||
if (!tree->root)
|
||||
hfs_btree_inc_height(tree);
|
||||
fd->bnode = hfs_bnode_find(tree, tree->leaf_head);
|
||||
if (IS_ERR(fd->bnode))
|
||||
return PTR_ERR(fd->bnode);
|
||||
node = hfs_bnode_find(tree, tree->leaf_head);
|
||||
if (IS_ERR(node))
|
||||
return PTR_ERR(node);
|
||||
fd->bnode = node;
|
||||
fd->record = -1;
|
||||
}
|
||||
new_node = NULL;
|
||||
|
||||
@ -77,13 +77,13 @@ again:
|
||||
cpu_to_be32(HFSP_HARDLINK_TYPE) &&
|
||||
entry.file.user_info.fdCreator ==
|
||||
cpu_to_be32(HFSP_HFSPLUS_CREATOR) &&
|
||||
HFSPLUS_SB(sb)->hidden_dir &&
|
||||
(entry.file.create_date ==
|
||||
HFSPLUS_I(HFSPLUS_SB(sb)->hidden_dir)->
|
||||
create_date ||
|
||||
entry.file.create_date ==
|
||||
HFSPLUS_I(d_inode(sb->s_root))->
|
||||
create_date) &&
|
||||
HFSPLUS_SB(sb)->hidden_dir) {
|
||||
create_date)) {
|
||||
struct qstr str;
|
||||
char name[32];
|
||||
|
||||
|
||||
53
fs/namei.c
53
fs/namei.c
@ -887,6 +887,8 @@ static inline void put_link(struct nameidata *nd)
|
||||
|
||||
int sysctl_protected_symlinks __read_mostly = 0;
|
||||
int sysctl_protected_hardlinks __read_mostly = 0;
|
||||
int sysctl_protected_fifos __read_mostly;
|
||||
int sysctl_protected_regular __read_mostly;
|
||||
|
||||
/**
|
||||
* may_follow_link - Check symlink following for unsafe situations
|
||||
@ -1003,6 +1005,45 @@ static int may_linkat(struct path *link)
|
||||
return -EPERM;
|
||||
}
|
||||
|
||||
/**
|
||||
* may_create_in_sticky - Check whether an O_CREAT open in a sticky directory
|
||||
* should be allowed, or not, on files that already
|
||||
* exist.
|
||||
* @dir: the sticky parent directory
|
||||
* @inode: the inode of the file to open
|
||||
*
|
||||
* Block an O_CREAT open of a FIFO (or a regular file) when:
|
||||
* - sysctl_protected_fifos (or sysctl_protected_regular) is enabled
|
||||
* - the file already exists
|
||||
* - we are in a sticky directory
|
||||
* - we don't own the file
|
||||
* - the owner of the directory doesn't own the file
|
||||
* - the directory is world writable
|
||||
* If the sysctl_protected_fifos (or sysctl_protected_regular) is set to 2
|
||||
* the directory doesn't have to be world writable: being group writable will
|
||||
* be enough.
|
||||
*
|
||||
* Returns 0 if the open is allowed, -ve on error.
|
||||
*/
|
||||
static int may_create_in_sticky(struct dentry * const dir,
|
||||
struct inode * const inode)
|
||||
{
|
||||
if ((!sysctl_protected_fifos && S_ISFIFO(inode->i_mode)) ||
|
||||
(!sysctl_protected_regular && S_ISREG(inode->i_mode)) ||
|
||||
likely(!(dir->d_inode->i_mode & S_ISVTX)) ||
|
||||
uid_eq(inode->i_uid, dir->d_inode->i_uid) ||
|
||||
uid_eq(current_fsuid(), inode->i_uid))
|
||||
return 0;
|
||||
|
||||
if (likely(dir->d_inode->i_mode & 0002) ||
|
||||
(dir->d_inode->i_mode & 0020 &&
|
||||
((sysctl_protected_fifos >= 2 && S_ISFIFO(inode->i_mode)) ||
|
||||
(sysctl_protected_regular >= 2 && S_ISREG(inode->i_mode))))) {
|
||||
return -EACCES;
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
||||
static __always_inline
|
||||
const char *get_link(struct nameidata *nd)
|
||||
{
|
||||
@ -3348,9 +3389,15 @@ finish_open:
|
||||
if (error)
|
||||
return error;
|
||||
audit_inode(nd->name, nd->path.dentry, 0);
|
||||
error = -EISDIR;
|
||||
if ((open_flag & O_CREAT) && d_is_dir(nd->path.dentry))
|
||||
goto out;
|
||||
if (open_flag & O_CREAT) {
|
||||
error = -EISDIR;
|
||||
if (d_is_dir(nd->path.dentry))
|
||||
goto out;
|
||||
error = may_create_in_sticky(dir,
|
||||
d_backing_inode(nd->path.dentry));
|
||||
if (unlikely(error))
|
||||
goto out;
|
||||
}
|
||||
error = -ENOTDIR;
|
||||
if ((nd->flags & LOOKUP_DIRECTORY) && !d_can_lookup(nd->path.dentry))
|
||||
goto out;
|
||||
|
||||
@ -225,6 +225,7 @@ out_unlock:
|
||||
return ret;
|
||||
}
|
||||
|
||||
#ifdef CONFIG_MMU
|
||||
static int vmcoredd_mmap_dumps(struct vm_area_struct *vma, unsigned long dst,
|
||||
u64 start, size_t size)
|
||||
{
|
||||
@ -259,6 +260,7 @@ out_unlock:
|
||||
mutex_unlock(&vmcoredd_mutex);
|
||||
return ret;
|
||||
}
|
||||
#endif /* CONFIG_MMU */
|
||||
#endif /* CONFIG_PROC_VMCORE_DEVICE_DUMP */
|
||||
|
||||
/* Read from the ELF header and then the crash dump. On error, negative value is
|
||||
|
||||
@ -340,17 +340,15 @@ out:
|
||||
* fatal_signal_pending()s, and the mmap_sem must be released before
|
||||
* returning it.
|
||||
*/
|
||||
int handle_userfault(struct vm_fault *vmf, unsigned long reason)
|
||||
vm_fault_t handle_userfault(struct vm_fault *vmf, unsigned long reason)
|
||||
{
|
||||
struct mm_struct *mm = vmf->vma->vm_mm;
|
||||
struct userfaultfd_ctx *ctx;
|
||||
struct userfaultfd_wait_queue uwq;
|
||||
int ret;
|
||||
vm_fault_t ret = VM_FAULT_SIGBUS;
|
||||
bool must_wait, return_to_userland;
|
||||
long blocking_state;
|
||||
|
||||
ret = VM_FAULT_SIGBUS;
|
||||
|
||||
/*
|
||||
* We don't do userfault handling for the final child pid update.
|
||||
*
|
||||
|
||||
@ -74,6 +74,8 @@ extern struct inodes_stat_t inodes_stat;
|
||||
extern int leases_enable, lease_break_time;
|
||||
extern int sysctl_protected_symlinks;
|
||||
extern int sysctl_protected_hardlinks;
|
||||
extern int sysctl_protected_fifos;
|
||||
extern int sysctl_protected_regular;
|
||||
|
||||
typedef __kernel_rwf_t rwf_t;
|
||||
|
||||
|
||||
@ -59,29 +59,32 @@ struct vm_area_struct;
|
||||
#define __GFP_MOVABLE ((__force gfp_t)___GFP_MOVABLE) /* ZONE_MOVABLE allowed */
|
||||
#define GFP_ZONEMASK (__GFP_DMA|__GFP_HIGHMEM|__GFP_DMA32|__GFP_MOVABLE)
|
||||
|
||||
/*
|
||||
/**
|
||||
* DOC: Page mobility and placement hints
|
||||
*
|
||||
* Page mobility and placement hints
|
||||
* ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
|
||||
*
|
||||
* These flags provide hints about how mobile the page is. Pages with similar
|
||||
* mobility are placed within the same pageblocks to minimise problems due
|
||||
* to external fragmentation.
|
||||
*
|
||||
* __GFP_MOVABLE (also a zone modifier) indicates that the page can be
|
||||
* moved by page migration during memory compaction or can be reclaimed.
|
||||
* %__GFP_MOVABLE (also a zone modifier) indicates that the page can be
|
||||
* moved by page migration during memory compaction or can be reclaimed.
|
||||
*
|
||||
* __GFP_RECLAIMABLE is used for slab allocations that specify
|
||||
* SLAB_RECLAIM_ACCOUNT and whose pages can be freed via shrinkers.
|
||||
* %__GFP_RECLAIMABLE is used for slab allocations that specify
|
||||
* SLAB_RECLAIM_ACCOUNT and whose pages can be freed via shrinkers.
|
||||
*
|
||||
* __GFP_WRITE indicates the caller intends to dirty the page. Where possible,
|
||||
* these pages will be spread between local zones to avoid all the dirty
|
||||
* pages being in one zone (fair zone allocation policy).
|
||||
* %__GFP_WRITE indicates the caller intends to dirty the page. Where possible,
|
||||
* these pages will be spread between local zones to avoid all the dirty
|
||||
* pages being in one zone (fair zone allocation policy).
|
||||
*
|
||||
* __GFP_HARDWALL enforces the cpuset memory allocation policy.
|
||||
* %__GFP_HARDWALL enforces the cpuset memory allocation policy.
|
||||
*
|
||||
* __GFP_THISNODE forces the allocation to be satisified from the requested
|
||||
* node with no fallbacks or placement policy enforcements.
|
||||
* %__GFP_THISNODE forces the allocation to be satisified from the requested
|
||||
* node with no fallbacks or placement policy enforcements.
|
||||
*
|
||||
* __GFP_ACCOUNT causes the allocation to be accounted to kmemcg.
|
||||
* %__GFP_ACCOUNT causes the allocation to be accounted to kmemcg.
|
||||
*/
|
||||
#define __GFP_RECLAIMABLE ((__force gfp_t)___GFP_RECLAIMABLE)
|
||||
#define __GFP_WRITE ((__force gfp_t)___GFP_WRITE)
|
||||
@ -89,54 +92,60 @@ struct vm_area_struct;
|
||||
#define __GFP_THISNODE ((__force gfp_t)___GFP_THISNODE)
|
||||
#define __GFP_ACCOUNT ((__force gfp_t)___GFP_ACCOUNT)
|
||||
|
||||
/*
|
||||
/**
|
||||
* DOC: Watermark modifiers
|
||||
*
|
||||
* Watermark modifiers -- controls access to emergency reserves
|
||||
* ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
|
||||
*
|
||||
* __GFP_HIGH indicates that the caller is high-priority and that granting
|
||||
* the request is necessary before the system can make forward progress.
|
||||
* For example, creating an IO context to clean pages.
|
||||
* %__GFP_HIGH indicates that the caller is high-priority and that granting
|
||||
* the request is necessary before the system can make forward progress.
|
||||
* For example, creating an IO context to clean pages.
|
||||
*
|
||||
* __GFP_ATOMIC indicates that the caller cannot reclaim or sleep and is
|
||||
* high priority. Users are typically interrupt handlers. This may be
|
||||
* used in conjunction with __GFP_HIGH
|
||||
* %__GFP_ATOMIC indicates that the caller cannot reclaim or sleep and is
|
||||
* high priority. Users are typically interrupt handlers. This may be
|
||||
* used in conjunction with %__GFP_HIGH
|
||||
*
|
||||
* __GFP_MEMALLOC allows access to all memory. This should only be used when
|
||||
* the caller guarantees the allocation will allow more memory to be freed
|
||||
* very shortly e.g. process exiting or swapping. Users either should
|
||||
* be the MM or co-ordinating closely with the VM (e.g. swap over NFS).
|
||||
* %__GFP_MEMALLOC allows access to all memory. This should only be used when
|
||||
* the caller guarantees the allocation will allow more memory to be freed
|
||||
* very shortly e.g. process exiting or swapping. Users either should
|
||||
* be the MM or co-ordinating closely with the VM (e.g. swap over NFS).
|
||||
*
|
||||
* __GFP_NOMEMALLOC is used to explicitly forbid access to emergency reserves.
|
||||
* This takes precedence over the __GFP_MEMALLOC flag if both are set.
|
||||
* %__GFP_NOMEMALLOC is used to explicitly forbid access to emergency reserves.
|
||||
* This takes precedence over the %__GFP_MEMALLOC flag if both are set.
|
||||
*/
|
||||
#define __GFP_ATOMIC ((__force gfp_t)___GFP_ATOMIC)
|
||||
#define __GFP_HIGH ((__force gfp_t)___GFP_HIGH)
|
||||
#define __GFP_MEMALLOC ((__force gfp_t)___GFP_MEMALLOC)
|
||||
#define __GFP_NOMEMALLOC ((__force gfp_t)___GFP_NOMEMALLOC)
|
||||
|
||||
/*
|
||||
/**
|
||||
* DOC: Reclaim modifiers
|
||||
*
|
||||
* Reclaim modifiers
|
||||
* ~~~~~~~~~~~~~~~~~
|
||||
*
|
||||
* __GFP_IO can start physical IO.
|
||||
* %__GFP_IO can start physical IO.
|
||||
*
|
||||
* __GFP_FS can call down to the low-level FS. Clearing the flag avoids the
|
||||
* allocator recursing into the filesystem which might already be holding
|
||||
* locks.
|
||||
* %__GFP_FS can call down to the low-level FS. Clearing the flag avoids the
|
||||
* allocator recursing into the filesystem which might already be holding
|
||||
* locks.
|
||||
*
|
||||
* __GFP_DIRECT_RECLAIM indicates that the caller may enter direct reclaim.
|
||||
* This flag can be cleared to avoid unnecessary delays when a fallback
|
||||
* option is available.
|
||||
* %__GFP_DIRECT_RECLAIM indicates that the caller may enter direct reclaim.
|
||||
* This flag can be cleared to avoid unnecessary delays when a fallback
|
||||
* option is available.
|
||||
*
|
||||
* __GFP_KSWAPD_RECLAIM indicates that the caller wants to wake kswapd when
|
||||
* the low watermark is reached and have it reclaim pages until the high
|
||||
* watermark is reached. A caller may wish to clear this flag when fallback
|
||||
* options are available and the reclaim is likely to disrupt the system. The
|
||||
* canonical example is THP allocation where a fallback is cheap but
|
||||
* reclaim/compaction may cause indirect stalls.
|
||||
* %__GFP_KSWAPD_RECLAIM indicates that the caller wants to wake kswapd when
|
||||
* the low watermark is reached and have it reclaim pages until the high
|
||||
* watermark is reached. A caller may wish to clear this flag when fallback
|
||||
* options are available and the reclaim is likely to disrupt the system. The
|
||||
* canonical example is THP allocation where a fallback is cheap but
|
||||
* reclaim/compaction may cause indirect stalls.
|
||||
*
|
||||
* __GFP_RECLAIM is shorthand to allow/forbid both direct and kswapd reclaim.
|
||||
* %__GFP_RECLAIM is shorthand to allow/forbid both direct and kswapd reclaim.
|
||||
*
|
||||
* The default allocator behavior depends on the request size. We have a concept
|
||||
* of so called costly allocations (with order > PAGE_ALLOC_COSTLY_ORDER).
|
||||
* of so called costly allocations (with order > %PAGE_ALLOC_COSTLY_ORDER).
|
||||
* !costly allocations are too essential to fail so they are implicitly
|
||||
* non-failing by default (with some exceptions like OOM victims might fail so
|
||||
* the caller still has to check for failures) while costly requests try to be
|
||||
@ -144,40 +153,40 @@ struct vm_area_struct;
|
||||
* The following three modifiers might be used to override some of these
|
||||
* implicit rules
|
||||
*
|
||||
* __GFP_NORETRY: The VM implementation will try only very lightweight
|
||||
* memory direct reclaim to get some memory under memory pressure (thus
|
||||
* it can sleep). It will avoid disruptive actions like OOM killer. The
|
||||
* caller must handle the failure which is quite likely to happen under
|
||||
* heavy memory pressure. The flag is suitable when failure can easily be
|
||||
* handled at small cost, such as reduced throughput
|
||||
* %__GFP_NORETRY: The VM implementation will try only very lightweight
|
||||
* memory direct reclaim to get some memory under memory pressure (thus
|
||||
* it can sleep). It will avoid disruptive actions like OOM killer. The
|
||||
* caller must handle the failure which is quite likely to happen under
|
||||
* heavy memory pressure. The flag is suitable when failure can easily be
|
||||
* handled at small cost, such as reduced throughput
|
||||
*
|
||||
* __GFP_RETRY_MAYFAIL: The VM implementation will retry memory reclaim
|
||||
* procedures that have previously failed if there is some indication
|
||||
* that progress has been made else where. It can wait for other
|
||||
* tasks to attempt high level approaches to freeing memory such as
|
||||
* compaction (which removes fragmentation) and page-out.
|
||||
* There is still a definite limit to the number of retries, but it is
|
||||
* a larger limit than with __GFP_NORETRY.
|
||||
* Allocations with this flag may fail, but only when there is
|
||||
* genuinely little unused memory. While these allocations do not
|
||||
* directly trigger the OOM killer, their failure indicates that
|
||||
* the system is likely to need to use the OOM killer soon. The
|
||||
* caller must handle failure, but can reasonably do so by failing
|
||||
* a higher-level request, or completing it only in a much less
|
||||
* efficient manner.
|
||||
* If the allocation does fail, and the caller is in a position to
|
||||
* free some non-essential memory, doing so could benefit the system
|
||||
* as a whole.
|
||||
* %__GFP_RETRY_MAYFAIL: The VM implementation will retry memory reclaim
|
||||
* procedures that have previously failed if there is some indication
|
||||
* that progress has been made else where. It can wait for other
|
||||
* tasks to attempt high level approaches to freeing memory such as
|
||||
* compaction (which removes fragmentation) and page-out.
|
||||
* There is still a definite limit to the number of retries, but it is
|
||||
* a larger limit than with %__GFP_NORETRY.
|
||||
* Allocations with this flag may fail, but only when there is
|
||||
* genuinely little unused memory. While these allocations do not
|
||||
* directly trigger the OOM killer, their failure indicates that
|
||||
* the system is likely to need to use the OOM killer soon. The
|
||||
* caller must handle failure, but can reasonably do so by failing
|
||||
* a higher-level request, or completing it only in a much less
|
||||
* efficient manner.
|
||||
* If the allocation does fail, and the caller is in a position to
|
||||
* free some non-essential memory, doing so could benefit the system
|
||||
* as a whole.
|
||||
*
|
||||
* __GFP_NOFAIL: The VM implementation _must_ retry infinitely: the caller
|
||||
* cannot handle allocation failures. The allocation could block
|
||||
* indefinitely but will never return with failure. Testing for
|
||||
* failure is pointless.
|
||||
* New users should be evaluated carefully (and the flag should be
|
||||
* used only when there is no reasonable failure policy) but it is
|
||||
* definitely preferable to use the flag rather than opencode endless
|
||||
* loop around allocator.
|
||||
* Using this flag for costly allocations is _highly_ discouraged.
|
||||
* %__GFP_NOFAIL: The VM implementation _must_ retry infinitely: the caller
|
||||
* cannot handle allocation failures. The allocation could block
|
||||
* indefinitely but will never return with failure. Testing for
|
||||
* failure is pointless.
|
||||
* New users should be evaluated carefully (and the flag should be
|
||||
* used only when there is no reasonable failure policy) but it is
|
||||
* definitely preferable to use the flag rather than opencode endless
|
||||
* loop around allocator.
|
||||
* Using this flag for costly allocations is _highly_ discouraged.
|
||||
*/
|
||||
#define __GFP_IO ((__force gfp_t)___GFP_IO)
|
||||
#define __GFP_FS ((__force gfp_t)___GFP_FS)
|
||||
@ -188,14 +197,17 @@ struct vm_area_struct;
|
||||
#define __GFP_NOFAIL ((__force gfp_t)___GFP_NOFAIL)
|
||||
#define __GFP_NORETRY ((__force gfp_t)___GFP_NORETRY)
|
||||
|
||||
/*
|
||||
/**
|
||||
* DOC: Action modifiers
|
||||
*
|
||||
* Action modifiers
|
||||
* ~~~~~~~~~~~~~~~~
|
||||
*
|
||||
* __GFP_NOWARN suppresses allocation failure reports.
|
||||
* %__GFP_NOWARN suppresses allocation failure reports.
|
||||
*
|
||||
* __GFP_COMP address compound page metadata.
|
||||
* %__GFP_COMP address compound page metadata.
|
||||
*
|
||||
* __GFP_ZERO returns a zeroed page on success.
|
||||
* %__GFP_ZERO returns a zeroed page on success.
|
||||
*/
|
||||
#define __GFP_NOWARN ((__force gfp_t)___GFP_NOWARN)
|
||||
#define __GFP_COMP ((__force gfp_t)___GFP_COMP)
|
||||
@ -208,66 +220,71 @@ struct vm_area_struct;
|
||||
#define __GFP_BITS_SHIFT (23 + IS_ENABLED(CONFIG_LOCKDEP))
|
||||
#define __GFP_BITS_MASK ((__force gfp_t)((1 << __GFP_BITS_SHIFT) - 1))
|
||||
|
||||
/*
|
||||
/**
|
||||
* DOC: Useful GFP flag combinations
|
||||
*
|
||||
* Useful GFP flag combinations
|
||||
* ~~~~~~~~~~~~~~~~~~~~~~~~~~~~
|
||||
*
|
||||
* Useful GFP flag combinations that are commonly used. It is recommended
|
||||
* that subsystems start with one of these combinations and then set/clear
|
||||
* __GFP_FOO flags as necessary.
|
||||
* %__GFP_FOO flags as necessary.
|
||||
*
|
||||
* GFP_ATOMIC users can not sleep and need the allocation to succeed. A lower
|
||||
* watermark is applied to allow access to "atomic reserves"
|
||||
* %GFP_ATOMIC users can not sleep and need the allocation to succeed. A lower
|
||||
* watermark is applied to allow access to "atomic reserves"
|
||||
*
|
||||
* GFP_KERNEL is typical for kernel-internal allocations. The caller requires
|
||||
* ZONE_NORMAL or a lower zone for direct access but can direct reclaim.
|
||||
* %GFP_KERNEL is typical for kernel-internal allocations. The caller requires
|
||||
* %ZONE_NORMAL or a lower zone for direct access but can direct reclaim.
|
||||
*
|
||||
* GFP_KERNEL_ACCOUNT is the same as GFP_KERNEL, except the allocation is
|
||||
* accounted to kmemcg.
|
||||
* %GFP_KERNEL_ACCOUNT is the same as GFP_KERNEL, except the allocation is
|
||||
* accounted to kmemcg.
|
||||
*
|
||||
* GFP_NOWAIT is for kernel allocations that should not stall for direct
|
||||
* reclaim, start physical IO or use any filesystem callback.
|
||||
* %GFP_NOWAIT is for kernel allocations that should not stall for direct
|
||||
* reclaim, start physical IO or use any filesystem callback.
|
||||
*
|
||||
* GFP_NOIO will use direct reclaim to discard clean pages or slab pages
|
||||
* that do not require the starting of any physical IO.
|
||||
* Please try to avoid using this flag directly and instead use
|
||||
* memalloc_noio_{save,restore} to mark the whole scope which cannot
|
||||
* perform any IO with a short explanation why. All allocation requests
|
||||
* will inherit GFP_NOIO implicitly.
|
||||
* %GFP_NOIO will use direct reclaim to discard clean pages or slab pages
|
||||
* that do not require the starting of any physical IO.
|
||||
* Please try to avoid using this flag directly and instead use
|
||||
* memalloc_noio_{save,restore} to mark the whole scope which cannot
|
||||
* perform any IO with a short explanation why. All allocation requests
|
||||
* will inherit GFP_NOIO implicitly.
|
||||
*
|
||||
* GFP_NOFS will use direct reclaim but will not use any filesystem interfaces.
|
||||
* Please try to avoid using this flag directly and instead use
|
||||
* memalloc_nofs_{save,restore} to mark the whole scope which cannot/shouldn't
|
||||
* recurse into the FS layer with a short explanation why. All allocation
|
||||
* requests will inherit GFP_NOFS implicitly.
|
||||
* %GFP_NOFS will use direct reclaim but will not use any filesystem interfaces.
|
||||
* Please try to avoid using this flag directly and instead use
|
||||
* memalloc_nofs_{save,restore} to mark the whole scope which cannot/shouldn't
|
||||
* recurse into the FS layer with a short explanation why. All allocation
|
||||
* requests will inherit GFP_NOFS implicitly.
|
||||
*
|
||||
* GFP_USER is for userspace allocations that also need to be directly
|
||||
* accessibly by the kernel or hardware. It is typically used by hardware
|
||||
* for buffers that are mapped to userspace (e.g. graphics) that hardware
|
||||
* still must DMA to. cpuset limits are enforced for these allocations.
|
||||
* %GFP_USER is for userspace allocations that also need to be directly
|
||||
* accessibly by the kernel or hardware. It is typically used by hardware
|
||||
* for buffers that are mapped to userspace (e.g. graphics) that hardware
|
||||
* still must DMA to. cpuset limits are enforced for these allocations.
|
||||
*
|
||||
* GFP_DMA exists for historical reasons and should be avoided where possible.
|
||||
* The flags indicates that the caller requires that the lowest zone be
|
||||
* used (ZONE_DMA or 16M on x86-64). Ideally, this would be removed but
|
||||
* it would require careful auditing as some users really require it and
|
||||
* others use the flag to avoid lowmem reserves in ZONE_DMA and treat the
|
||||
* lowest zone as a type of emergency reserve.
|
||||
* %GFP_DMA exists for historical reasons and should be avoided where possible.
|
||||
* The flags indicates that the caller requires that the lowest zone be
|
||||
* used (%ZONE_DMA or 16M on x86-64). Ideally, this would be removed but
|
||||
* it would require careful auditing as some users really require it and
|
||||
* others use the flag to avoid lowmem reserves in %ZONE_DMA and treat the
|
||||
* lowest zone as a type of emergency reserve.
|
||||
*
|
||||
* GFP_DMA32 is similar to GFP_DMA except that the caller requires a 32-bit
|
||||
* address.
|
||||
* %GFP_DMA32 is similar to %GFP_DMA except that the caller requires a 32-bit
|
||||
* address.
|
||||
*
|
||||
* GFP_HIGHUSER is for userspace allocations that may be mapped to userspace,
|
||||
* do not need to be directly accessible by the kernel but that cannot
|
||||
* move once in use. An example may be a hardware allocation that maps
|
||||
* data directly into userspace but has no addressing limitations.
|
||||
* %GFP_HIGHUSER is for userspace allocations that may be mapped to userspace,
|
||||
* do not need to be directly accessible by the kernel but that cannot
|
||||
* move once in use. An example may be a hardware allocation that maps
|
||||
* data directly into userspace but has no addressing limitations.
|
||||
*
|
||||
* GFP_HIGHUSER_MOVABLE is for userspace allocations that the kernel does not
|
||||
* need direct access to but can use kmap() when access is required. They
|
||||
* are expected to be movable via page reclaim or page migration. Typically,
|
||||
* pages on the LRU would also be allocated with GFP_HIGHUSER_MOVABLE.
|
||||
* %GFP_HIGHUSER_MOVABLE is for userspace allocations that the kernel does not
|
||||
* need direct access to but can use kmap() when access is required. They
|
||||
* are expected to be movable via page reclaim or page migration. Typically,
|
||||
* pages on the LRU would also be allocated with %GFP_HIGHUSER_MOVABLE.
|
||||
*
|
||||
* GFP_TRANSHUGE and GFP_TRANSHUGE_LIGHT are used for THP allocations. They are
|
||||
* compound allocations that will generally fail quickly if memory is not
|
||||
* available and will not wake kswapd/kcompactd on failure. The _LIGHT
|
||||
* version does not attempt reclaim/compaction at all and is by default used
|
||||
* in page fault path, while the non-light is used by khugepaged.
|
||||
* %GFP_TRANSHUGE and %GFP_TRANSHUGE_LIGHT are used for THP allocations. They
|
||||
* are compound allocations that will generally fail quickly if memory is not
|
||||
* available and will not wake kswapd/kcompactd on failure. The _LIGHT
|
||||
* version does not attempt reclaim/compaction at all and is by default used
|
||||
* in page fault path, while the non-light is used by khugepaged.
|
||||
*/
|
||||
#define GFP_ATOMIC (__GFP_HIGH|__GFP_ATOMIC|__GFP_KSWAPD_RECLAIM)
|
||||
#define GFP_KERNEL (__GFP_RECLAIM | __GFP_IO | __GFP_FS)
|
||||
|
||||
@ -6,7 +6,7 @@
|
||||
|
||||
#include <linux/fs.h> /* only for vma_is_dax() */
|
||||
|
||||
extern int do_huge_pmd_anonymous_page(struct vm_fault *vmf);
|
||||
extern vm_fault_t do_huge_pmd_anonymous_page(struct vm_fault *vmf);
|
||||
extern int copy_huge_pmd(struct mm_struct *dst_mm, struct mm_struct *src_mm,
|
||||
pmd_t *dst_pmd, pmd_t *src_pmd, unsigned long addr,
|
||||
struct vm_area_struct *vma);
|
||||
@ -23,7 +23,7 @@ static inline void huge_pud_set_accessed(struct vm_fault *vmf, pud_t orig_pud)
|
||||
}
|
||||
#endif
|
||||
|
||||
extern int do_huge_pmd_wp_page(struct vm_fault *vmf, pmd_t orig_pmd);
|
||||
extern vm_fault_t do_huge_pmd_wp_page(struct vm_fault *vmf, pmd_t orig_pmd);
|
||||
extern struct page *follow_trans_huge_pmd(struct vm_area_struct *vma,
|
||||
unsigned long addr,
|
||||
pmd_t *pmd,
|
||||
@ -216,7 +216,7 @@ struct page *follow_devmap_pmd(struct vm_area_struct *vma, unsigned long addr,
|
||||
struct page *follow_devmap_pud(struct vm_area_struct *vma, unsigned long addr,
|
||||
pud_t *pud, int flags);
|
||||
|
||||
extern int do_huge_pmd_numa_page(struct vm_fault *vmf, pmd_t orig_pmd);
|
||||
extern vm_fault_t do_huge_pmd_numa_page(struct vm_fault *vmf, pmd_t orig_pmd);
|
||||
|
||||
extern struct page *huge_zero_page;
|
||||
|
||||
@ -321,7 +321,8 @@ static inline spinlock_t *pud_trans_huge_lock(pud_t *pud,
|
||||
return NULL;
|
||||
}
|
||||
|
||||
static inline int do_huge_pmd_numa_page(struct vm_fault *vmf, pmd_t orig_pmd)
|
||||
static inline vm_fault_t do_huge_pmd_numa_page(struct vm_fault *vmf,
|
||||
pmd_t orig_pmd)
|
||||
{
|
||||
return 0;
|
||||
}
|
||||
|
||||
@ -105,7 +105,7 @@ void hugetlb_report_meminfo(struct seq_file *);
|
||||
int hugetlb_report_node_meminfo(int, char *);
|
||||
void hugetlb_show_meminfo(void);
|
||||
unsigned long hugetlb_total_pages(void);
|
||||
int hugetlb_fault(struct mm_struct *mm, struct vm_area_struct *vma,
|
||||
vm_fault_t hugetlb_fault(struct mm_struct *mm, struct vm_area_struct *vma,
|
||||
unsigned long address, unsigned int flags);
|
||||
int hugetlb_mcopy_atomic_pte(struct mm_struct *dst_mm, pte_t *dst_pte,
|
||||
struct vm_area_struct *dst_vma,
|
||||
|
||||
@ -728,10 +728,10 @@ static inline pte_t maybe_mkwrite(pte_t pte, struct vm_area_struct *vma)
|
||||
return pte;
|
||||
}
|
||||
|
||||
int alloc_set_pte(struct vm_fault *vmf, struct mem_cgroup *memcg,
|
||||
vm_fault_t alloc_set_pte(struct vm_fault *vmf, struct mem_cgroup *memcg,
|
||||
struct page *page);
|
||||
int finish_fault(struct vm_fault *vmf);
|
||||
int finish_mkwrite_fault(struct vm_fault *vmf);
|
||||
vm_fault_t finish_fault(struct vm_fault *vmf);
|
||||
vm_fault_t finish_mkwrite_fault(struct vm_fault *vmf);
|
||||
#endif
|
||||
|
||||
/*
|
||||
@ -1403,8 +1403,8 @@ int generic_error_remove_page(struct address_space *mapping, struct page *page);
|
||||
int invalidate_inode_page(struct page *page);
|
||||
|
||||
#ifdef CONFIG_MMU
|
||||
extern int handle_mm_fault(struct vm_area_struct *vma, unsigned long address,
|
||||
unsigned int flags);
|
||||
extern vm_fault_t handle_mm_fault(struct vm_area_struct *vma,
|
||||
unsigned long address, unsigned int flags);
|
||||
extern int fixup_user_fault(struct task_struct *tsk, struct mm_struct *mm,
|
||||
unsigned long address, unsigned int fault_flags,
|
||||
bool *unlocked);
|
||||
@ -1413,7 +1413,7 @@ void unmap_mapping_pages(struct address_space *mapping,
|
||||
void unmap_mapping_range(struct address_space *mapping,
|
||||
loff_t const holebegin, loff_t const holelen, int even_cows);
|
||||
#else
|
||||
static inline int handle_mm_fault(struct vm_area_struct *vma,
|
||||
static inline vm_fault_t handle_mm_fault(struct vm_area_struct *vma,
|
||||
unsigned long address, unsigned int flags)
|
||||
{
|
||||
/* should never happen if there's no MMU */
|
||||
@ -2563,7 +2563,7 @@ static inline struct page *follow_page(struct vm_area_struct *vma,
|
||||
#define FOLL_COW 0x4000 /* internal GUP flag */
|
||||
#define FOLL_ANON 0x8000 /* don't do file mappings */
|
||||
|
||||
static inline int vm_fault_to_errno(int vm_fault, int foll_flags)
|
||||
static inline int vm_fault_to_errno(vm_fault_t vm_fault, int foll_flags)
|
||||
{
|
||||
if (vm_fault & VM_FAULT_OOM)
|
||||
return -ENOMEM;
|
||||
|
||||
@ -88,7 +88,7 @@ static inline bool mm_is_oom_victim(struct mm_struct *mm)
|
||||
*
|
||||
* Return 0 when the PF is safe VM_FAULT_SIGBUS otherwise.
|
||||
*/
|
||||
static inline int check_stable_address_space(struct mm_struct *mm)
|
||||
static inline vm_fault_t check_stable_address_space(struct mm_struct *mm)
|
||||
{
|
||||
if (unlikely(test_bit(MMF_UNSTABLE, &mm->flags)))
|
||||
return VM_FAULT_SIGBUS;
|
||||
|
||||
@ -369,8 +369,13 @@ PAGEFLAG_FALSE(Uncached)
|
||||
PAGEFLAG(HWPoison, hwpoison, PF_ANY)
|
||||
TESTSCFLAG(HWPoison, hwpoison, PF_ANY)
|
||||
#define __PG_HWPOISON (1UL << PG_hwpoison)
|
||||
extern bool set_hwpoison_free_buddy_page(struct page *page);
|
||||
#else
|
||||
PAGEFLAG_FALSE(HWPoison)
|
||||
static inline bool set_hwpoison_free_buddy_page(struct page *page)
|
||||
{
|
||||
return 0;
|
||||
}
|
||||
#define __PG_HWPOISON 0
|
||||
#endif
|
||||
|
||||
|
||||
@ -4,6 +4,7 @@
|
||||
|
||||
#include <linux/radix-tree.h>
|
||||
#include <linux/bug.h>
|
||||
#include <linux/mm_types.h>
|
||||
|
||||
/*
|
||||
* swapcache pages are stored in the swapper_space radix tree. We want to
|
||||
@ -134,7 +135,7 @@ static inline struct page *device_private_entry_to_page(swp_entry_t entry)
|
||||
return pfn_to_page(swp_offset(entry));
|
||||
}
|
||||
|
||||
int device_private_entry_fault(struct vm_area_struct *vma,
|
||||
vm_fault_t device_private_entry_fault(struct vm_area_struct *vma,
|
||||
unsigned long addr,
|
||||
swp_entry_t entry,
|
||||
unsigned int flags,
|
||||
@ -169,7 +170,7 @@ static inline struct page *device_private_entry_to_page(swp_entry_t entry)
|
||||
return NULL;
|
||||
}
|
||||
|
||||
static inline int device_private_entry_fault(struct vm_area_struct *vma,
|
||||
static inline vm_fault_t device_private_entry_fault(struct vm_area_struct *vma,
|
||||
unsigned long addr,
|
||||
swp_entry_t entry,
|
||||
unsigned int flags,
|
||||
@ -340,11 +341,6 @@ static inline int is_hwpoison_entry(swp_entry_t entry)
|
||||
return swp_type(entry) == SWP_HWPOISON;
|
||||
}
|
||||
|
||||
static inline bool test_set_page_hwpoison(struct page *page)
|
||||
{
|
||||
return TestSetPageHWPoison(page);
|
||||
}
|
||||
|
||||
static inline void num_poisoned_pages_inc(void)
|
||||
{
|
||||
atomic_long_inc(&num_poisoned_pages);
|
||||
@ -367,11 +363,6 @@ static inline int is_hwpoison_entry(swp_entry_t swp)
|
||||
return 0;
|
||||
}
|
||||
|
||||
static inline bool test_set_page_hwpoison(struct page *page)
|
||||
{
|
||||
return false;
|
||||
}
|
||||
|
||||
static inline void num_poisoned_pages_inc(void)
|
||||
{
|
||||
}
|
||||
|
||||
@ -28,7 +28,7 @@
|
||||
#define UFFD_SHARED_FCNTL_FLAGS (O_CLOEXEC | O_NONBLOCK)
|
||||
#define UFFD_FLAGS_SET (EFD_SHARED_FCNTL_FLAGS)
|
||||
|
||||
extern int handle_userfault(struct vm_fault *vmf, unsigned long reason);
|
||||
extern vm_fault_t handle_userfault(struct vm_fault *vmf, unsigned long reason);
|
||||
|
||||
extern ssize_t mcopy_atomic(struct mm_struct *dst_mm, unsigned long dst_start,
|
||||
unsigned long src_start, unsigned long len,
|
||||
@ -77,7 +77,8 @@ extern void userfaultfd_unmap_complete(struct mm_struct *mm,
|
||||
#else /* CONFIG_USERFAULTFD */
|
||||
|
||||
/* mm helpers */
|
||||
static inline int handle_userfault(struct vm_fault *vmf, unsigned long reason)
|
||||
static inline vm_fault_t handle_userfault(struct vm_fault *vmf,
|
||||
unsigned long reason)
|
||||
{
|
||||
return VM_FAULT_SIGBUS;
|
||||
}
|
||||
|
||||
@ -4,7 +4,7 @@
|
||||
* Copyright (C) 2008 Thomas Gleixner <tglx@linutronix.de>
|
||||
* Copyright (C) 2008-2011 Red Hat, Inc., Ingo Molnar
|
||||
* Copyright (C) 2008-2011 Red Hat, Inc., Peter Zijlstra
|
||||
* Copyright © 2009 Paul Mackerras, IBM Corp. <paulus@au1.ibm.com>
|
||||
* Copyright © 2009 Paul Mackerras, IBM Corp. <paulus@au1.ibm.com>
|
||||
*
|
||||
* For licensing details see kernel-base/COPYING
|
||||
*/
|
||||
|
||||
@ -43,7 +43,7 @@ static unsigned long order_at(struct resource *res, unsigned long pgoff)
|
||||
pgoff += 1UL << order, order = order_at((res), pgoff))
|
||||
|
||||
#if IS_ENABLED(CONFIG_DEVICE_PRIVATE)
|
||||
int device_private_entry_fault(struct vm_area_struct *vma,
|
||||
vm_fault_t device_private_entry_fault(struct vm_area_struct *vma,
|
||||
unsigned long addr,
|
||||
swp_entry_t entry,
|
||||
unsigned int flags,
|
||||
|
||||
@ -1807,6 +1807,24 @@ static struct ctl_table fs_table[] = {
|
||||
.extra1 = &zero,
|
||||
.extra2 = &one,
|
||||
},
|
||||
{
|
||||
.procname = "protected_fifos",
|
||||
.data = &sysctl_protected_fifos,
|
||||
.maxlen = sizeof(int),
|
||||
.mode = 0600,
|
||||
.proc_handler = proc_dointvec_minmax,
|
||||
.extra1 = &zero,
|
||||
.extra2 = &two,
|
||||
},
|
||||
{
|
||||
.procname = "protected_regular",
|
||||
.data = &sysctl_protected_regular,
|
||||
.maxlen = sizeof(int),
|
||||
.mode = 0600,
|
||||
.proc_handler = proc_dointvec_minmax,
|
||||
.extra1 = &zero,
|
||||
.extra2 = &two,
|
||||
},
|
||||
{
|
||||
.procname = "suid_dumpable",
|
||||
.data = &suid_dumpable,
|
||||
|
||||
File diff suppressed because it is too large
Load Diff
File diff suppressed because it is too large
Load Diff
File diff suppressed because it is too large
Load Diff
File diff suppressed because it is too large
Load Diff
4
mm/gup.c
4
mm/gup.c
@ -497,7 +497,7 @@ static int faultin_page(struct task_struct *tsk, struct vm_area_struct *vma,
|
||||
unsigned long address, unsigned int *flags, int *nonblocking)
|
||||
{
|
||||
unsigned int fault_flags = 0;
|
||||
int ret;
|
||||
vm_fault_t ret;
|
||||
|
||||
/* mlock all present pages, but do not fault in new pages */
|
||||
if ((*flags & (FOLL_POPULATE | FOLL_MLOCK)) == FOLL_MLOCK)
|
||||
@ -818,7 +818,7 @@ int fixup_user_fault(struct task_struct *tsk, struct mm_struct *mm,
|
||||
bool *unlocked)
|
||||
{
|
||||
struct vm_area_struct *vma;
|
||||
int ret, major = 0;
|
||||
vm_fault_t ret, major = 0;
|
||||
|
||||
if (unlocked)
|
||||
fault_flags |= FAULT_FLAG_ALLOW_RETRY;
|
||||
|
||||
@ -541,14 +541,14 @@ unsigned long thp_get_unmapped_area(struct file *filp, unsigned long addr,
|
||||
}
|
||||
EXPORT_SYMBOL_GPL(thp_get_unmapped_area);
|
||||
|
||||
static int __do_huge_pmd_anonymous_page(struct vm_fault *vmf, struct page *page,
|
||||
gfp_t gfp)
|
||||
static vm_fault_t __do_huge_pmd_anonymous_page(struct vm_fault *vmf,
|
||||
struct page *page, gfp_t gfp)
|
||||
{
|
||||
struct vm_area_struct *vma = vmf->vma;
|
||||
struct mem_cgroup *memcg;
|
||||
pgtable_t pgtable;
|
||||
unsigned long haddr = vmf->address & HPAGE_PMD_MASK;
|
||||
int ret = 0;
|
||||
vm_fault_t ret = 0;
|
||||
|
||||
VM_BUG_ON_PAGE(!PageCompound(page), page);
|
||||
|
||||
@ -584,15 +584,15 @@ static int __do_huge_pmd_anonymous_page(struct vm_fault *vmf, struct page *page,
|
||||
|
||||
/* Deliver the page fault to userland */
|
||||
if (userfaultfd_missing(vma)) {
|
||||
int ret;
|
||||
vm_fault_t ret2;
|
||||
|
||||
spin_unlock(vmf->ptl);
|
||||
mem_cgroup_cancel_charge(page, memcg, true);
|
||||
put_page(page);
|
||||
pte_free(vma->vm_mm, pgtable);
|
||||
ret = handle_userfault(vmf, VM_UFFD_MISSING);
|
||||
VM_BUG_ON(ret & VM_FAULT_FALLBACK);
|
||||
return ret;
|
||||
ret2 = handle_userfault(vmf, VM_UFFD_MISSING);
|
||||
VM_BUG_ON(ret2 & VM_FAULT_FALLBACK);
|
||||
return ret2;
|
||||
}
|
||||
|
||||
entry = mk_huge_pmd(page, vma->vm_page_prot);
|
||||
@ -663,7 +663,7 @@ static bool set_huge_zero_page(pgtable_t pgtable, struct mm_struct *mm,
|
||||
return true;
|
||||
}
|
||||
|
||||
int do_huge_pmd_anonymous_page(struct vm_fault *vmf)
|
||||
vm_fault_t do_huge_pmd_anonymous_page(struct vm_fault *vmf)
|
||||
{
|
||||
struct vm_area_struct *vma = vmf->vma;
|
||||
gfp_t gfp;
|
||||
@ -682,7 +682,7 @@ int do_huge_pmd_anonymous_page(struct vm_fault *vmf)
|
||||
pgtable_t pgtable;
|
||||
struct page *zero_page;
|
||||
bool set;
|
||||
int ret;
|
||||
vm_fault_t ret;
|
||||
pgtable = pte_alloc_one(vma->vm_mm, haddr);
|
||||
if (unlikely(!pgtable))
|
||||
return VM_FAULT_OOM;
|
||||
@ -1118,15 +1118,16 @@ unlock:
|
||||
spin_unlock(vmf->ptl);
|
||||
}
|
||||
|
||||
static int do_huge_pmd_wp_page_fallback(struct vm_fault *vmf, pmd_t orig_pmd,
|
||||
struct page *page)
|
||||
static vm_fault_t do_huge_pmd_wp_page_fallback(struct vm_fault *vmf,
|
||||
pmd_t orig_pmd, struct page *page)
|
||||
{
|
||||
struct vm_area_struct *vma = vmf->vma;
|
||||
unsigned long haddr = vmf->address & HPAGE_PMD_MASK;
|
||||
struct mem_cgroup *memcg;
|
||||
pgtable_t pgtable;
|
||||
pmd_t _pmd;
|
||||
int ret = 0, i;
|
||||
int i;
|
||||
vm_fault_t ret = 0;
|
||||
struct page **pages;
|
||||
unsigned long mmun_start; /* For mmu_notifiers */
|
||||
unsigned long mmun_end; /* For mmu_notifiers */
|
||||
@ -1236,7 +1237,7 @@ out_free_pages:
|
||||
goto out;
|
||||
}
|
||||
|
||||
int do_huge_pmd_wp_page(struct vm_fault *vmf, pmd_t orig_pmd)
|
||||
vm_fault_t do_huge_pmd_wp_page(struct vm_fault *vmf, pmd_t orig_pmd)
|
||||
{
|
||||
struct vm_area_struct *vma = vmf->vma;
|
||||
struct page *page = NULL, *new_page;
|
||||
@ -1245,7 +1246,7 @@ int do_huge_pmd_wp_page(struct vm_fault *vmf, pmd_t orig_pmd)
|
||||
unsigned long mmun_start; /* For mmu_notifiers */
|
||||
unsigned long mmun_end; /* For mmu_notifiers */
|
||||
gfp_t huge_gfp; /* for allocation and charge */
|
||||
int ret = 0;
|
||||
vm_fault_t ret = 0;
|
||||
|
||||
vmf->ptl = pmd_lockptr(vma->vm_mm, vmf->pmd);
|
||||
VM_BUG_ON_VMA(!vma->anon_vma, vma);
|
||||
@ -1457,7 +1458,7 @@ out:
|
||||
}
|
||||
|
||||
/* NUMA hinting page fault entry point for trans huge pmds */
|
||||
int do_huge_pmd_numa_page(struct vm_fault *vmf, pmd_t pmd)
|
||||
vm_fault_t do_huge_pmd_numa_page(struct vm_fault *vmf, pmd_t pmd)
|
||||
{
|
||||
struct vm_area_struct *vma = vmf->vma;
|
||||
struct anon_vma *anon_vma = NULL;
|
||||
|
||||
40
mm/hugetlb.c
40
mm/hugetlb.c
@ -1479,22 +1479,20 @@ static int free_pool_huge_page(struct hstate *h, nodemask_t *nodes_allowed,
|
||||
/*
|
||||
* Dissolve a given free hugepage into free buddy pages. This function does
|
||||
* nothing for in-use (including surplus) hugepages. Returns -EBUSY if the
|
||||
* number of free hugepages would be reduced below the number of reserved
|
||||
* hugepages.
|
||||
* dissolution fails because a give page is not a free hugepage, or because
|
||||
* free hugepages are fully reserved.
|
||||
*/
|
||||
int dissolve_free_huge_page(struct page *page)
|
||||
{
|
||||
int rc = 0;
|
||||
int rc = -EBUSY;
|
||||
|
||||
spin_lock(&hugetlb_lock);
|
||||
if (PageHuge(page) && !page_count(page)) {
|
||||
struct page *head = compound_head(page);
|
||||
struct hstate *h = page_hstate(head);
|
||||
int nid = page_to_nid(head);
|
||||
if (h->free_huge_pages - h->resv_huge_pages == 0) {
|
||||
rc = -EBUSY;
|
||||
if (h->free_huge_pages - h->resv_huge_pages == 0)
|
||||
goto out;
|
||||
}
|
||||
/*
|
||||
* Move PageHWPoison flag from head page to the raw error page,
|
||||
* which makes any subpages rather than the error page reusable.
|
||||
@ -1508,6 +1506,7 @@ int dissolve_free_huge_page(struct page *page)
|
||||
h->free_huge_pages_node[nid]--;
|
||||
h->max_huge_pages--;
|
||||
update_and_free_page(h, head);
|
||||
rc = 0;
|
||||
}
|
||||
out:
|
||||
spin_unlock(&hugetlb_lock);
|
||||
@ -3502,14 +3501,15 @@ static void unmap_ref_private(struct mm_struct *mm, struct vm_area_struct *vma,
|
||||
* cannot race with other handlers or page migration.
|
||||
* Keep the pte_same checks anyway to make transition from the mutex easier.
|
||||
*/
|
||||
static int hugetlb_cow(struct mm_struct *mm, struct vm_area_struct *vma,
|
||||
static vm_fault_t hugetlb_cow(struct mm_struct *mm, struct vm_area_struct *vma,
|
||||
unsigned long address, pte_t *ptep,
|
||||
struct page *pagecache_page, spinlock_t *ptl)
|
||||
{
|
||||
pte_t pte;
|
||||
struct hstate *h = hstate_vma(vma);
|
||||
struct page *old_page, *new_page;
|
||||
int ret = 0, outside_reserve = 0;
|
||||
int outside_reserve = 0;
|
||||
vm_fault_t ret = 0;
|
||||
unsigned long mmun_start; /* For mmu_notifiers */
|
||||
unsigned long mmun_end; /* For mmu_notifiers */
|
||||
unsigned long haddr = address & huge_page_mask(h);
|
||||
@ -3573,8 +3573,7 @@ retry_avoidcopy:
|
||||
return 0;
|
||||
}
|
||||
|
||||
ret = (PTR_ERR(new_page) == -ENOMEM) ?
|
||||
VM_FAULT_OOM : VM_FAULT_SIGBUS;
|
||||
ret = vmf_error(PTR_ERR(new_page));
|
||||
goto out_release_old;
|
||||
}
|
||||
|
||||
@ -3677,12 +3676,13 @@ int huge_add_to_page_cache(struct page *page, struct address_space *mapping,
|
||||
return 0;
|
||||
}
|
||||
|
||||
static int hugetlb_no_page(struct mm_struct *mm, struct vm_area_struct *vma,
|
||||
struct address_space *mapping, pgoff_t idx,
|
||||
unsigned long address, pte_t *ptep, unsigned int flags)
|
||||
static vm_fault_t hugetlb_no_page(struct mm_struct *mm,
|
||||
struct vm_area_struct *vma,
|
||||
struct address_space *mapping, pgoff_t idx,
|
||||
unsigned long address, pte_t *ptep, unsigned int flags)
|
||||
{
|
||||
struct hstate *h = hstate_vma(vma);
|
||||
int ret = VM_FAULT_SIGBUS;
|
||||
vm_fault_t ret = VM_FAULT_SIGBUS;
|
||||
int anon_rmap = 0;
|
||||
unsigned long size;
|
||||
struct page *page;
|
||||
@ -3745,11 +3745,7 @@ retry:
|
||||
|
||||
page = alloc_huge_page(vma, haddr, 0);
|
||||
if (IS_ERR(page)) {
|
||||
ret = PTR_ERR(page);
|
||||
if (ret == -ENOMEM)
|
||||
ret = VM_FAULT_OOM;
|
||||
else
|
||||
ret = VM_FAULT_SIGBUS;
|
||||
ret = vmf_error(PTR_ERR(page));
|
||||
goto out;
|
||||
}
|
||||
clear_huge_page(page, address, pages_per_huge_page(h));
|
||||
@ -3873,12 +3869,12 @@ u32 hugetlb_fault_mutex_hash(struct hstate *h, struct mm_struct *mm,
|
||||
}
|
||||
#endif
|
||||
|
||||
int hugetlb_fault(struct mm_struct *mm, struct vm_area_struct *vma,
|
||||
vm_fault_t hugetlb_fault(struct mm_struct *mm, struct vm_area_struct *vma,
|
||||
unsigned long address, unsigned int flags)
|
||||
{
|
||||
pte_t *ptep, entry;
|
||||
spinlock_t *ptl;
|
||||
int ret;
|
||||
vm_fault_t ret;
|
||||
u32 hash;
|
||||
pgoff_t idx;
|
||||
struct page *page = NULL;
|
||||
@ -4208,7 +4204,7 @@ long follow_hugetlb_page(struct mm_struct *mm, struct vm_area_struct *vma,
|
||||
if (absent || is_swap_pte(huge_ptep_get(pte)) ||
|
||||
((flags & FOLL_WRITE) &&
|
||||
!huge_pte_write(huge_ptep_get(pte)))) {
|
||||
int ret;
|
||||
vm_fault_t ret;
|
||||
unsigned int fault_flags = 0;
|
||||
|
||||
if (pte)
|
||||
|
||||
@ -38,7 +38,7 @@
|
||||
|
||||
void page_writeback_init(void);
|
||||
|
||||
int do_swap_page(struct vm_fault *vmf);
|
||||
vm_fault_t do_swap_page(struct vm_fault *vmf);
|
||||
|
||||
void free_pgtables(struct mmu_gather *tlb, struct vm_area_struct *start_vma,
|
||||
unsigned long floor, unsigned long ceiling);
|
||||
|
||||
@ -880,7 +880,8 @@ static bool __collapse_huge_page_swapin(struct mm_struct *mm,
|
||||
unsigned long address, pmd_t *pmd,
|
||||
int referenced)
|
||||
{
|
||||
int swapped_in = 0, ret = 0;
|
||||
int swapped_in = 0;
|
||||
vm_fault_t ret = 0;
|
||||
struct vm_fault vmf = {
|
||||
.vma = vma,
|
||||
.address = address,
|
||||
|
||||
@ -57,6 +57,7 @@
|
||||
#include <linux/mm_inline.h>
|
||||
#include <linux/kfifo.h>
|
||||
#include <linux/ratelimit.h>
|
||||
#include <linux/page-isolation.h>
|
||||
#include "internal.h"
|
||||
#include "ras/ras_event.h"
|
||||
|
||||
@ -1598,8 +1599,18 @@ static int soft_offline_huge_page(struct page *page, int flags)
|
||||
if (ret > 0)
|
||||
ret = -EIO;
|
||||
} else {
|
||||
if (PageHuge(page))
|
||||
dissolve_free_huge_page(page);
|
||||
/*
|
||||
* We set PG_hwpoison only when the migration source hugepage
|
||||
* was successfully dissolved, because otherwise hwpoisoned
|
||||
* hugepage remains on free hugepage list, then userspace will
|
||||
* find it as SIGBUS by allocation failure. That's not expected
|
||||
* in soft-offlining.
|
||||
*/
|
||||
ret = dissolve_free_huge_page(page);
|
||||
if (!ret) {
|
||||
if (set_hwpoison_free_buddy_page(page))
|
||||
num_poisoned_pages_inc();
|
||||
}
|
||||
}
|
||||
return ret;
|
||||
}
|
||||
@ -1687,6 +1698,7 @@ static int __soft_offline_page(struct page *page, int flags)
|
||||
static int soft_offline_in_use_page(struct page *page, int flags)
|
||||
{
|
||||
int ret;
|
||||
int mt;
|
||||
struct page *hpage = compound_head(page);
|
||||
|
||||
if (!PageHuge(page) && PageTransHuge(hpage)) {
|
||||
@ -1705,23 +1717,37 @@ static int soft_offline_in_use_page(struct page *page, int flags)
|
||||
put_hwpoison_page(hpage);
|
||||
}
|
||||
|
||||
/*
|
||||
* Setting MIGRATE_ISOLATE here ensures that the page will be linked
|
||||
* to free list immediately (not via pcplist) when released after
|
||||
* successful page migration. Otherwise we can't guarantee that the
|
||||
* page is really free after put_page() returns, so
|
||||
* set_hwpoison_free_buddy_page() highly likely fails.
|
||||
*/
|
||||
mt = get_pageblock_migratetype(page);
|
||||
set_pageblock_migratetype(page, MIGRATE_ISOLATE);
|
||||
if (PageHuge(page))
|
||||
ret = soft_offline_huge_page(page, flags);
|
||||
else
|
||||
ret = __soft_offline_page(page, flags);
|
||||
|
||||
set_pageblock_migratetype(page, mt);
|
||||
return ret;
|
||||
}
|
||||
|
||||
static void soft_offline_free_page(struct page *page)
|
||||
static int soft_offline_free_page(struct page *page)
|
||||
{
|
||||
int rc = 0;
|
||||
struct page *head = compound_head(page);
|
||||
|
||||
if (!TestSetPageHWPoison(head)) {
|
||||
num_poisoned_pages_inc();
|
||||
if (PageHuge(head))
|
||||
dissolve_free_huge_page(page);
|
||||
if (PageHuge(head))
|
||||
rc = dissolve_free_huge_page(page);
|
||||
if (!rc) {
|
||||
if (set_hwpoison_free_buddy_page(page))
|
||||
num_poisoned_pages_inc();
|
||||
else
|
||||
rc = -EBUSY;
|
||||
}
|
||||
return rc;
|
||||
}
|
||||
|
||||
/**
|
||||
@ -1765,7 +1791,7 @@ int soft_offline_page(struct page *page, int flags)
|
||||
if (ret > 0)
|
||||
ret = soft_offline_in_use_page(page, flags);
|
||||
else if (ret == 0)
|
||||
soft_offline_free_page(page);
|
||||
ret = soft_offline_free_page(page);
|
||||
|
||||
return ret;
|
||||
}
|
||||
|
||||
90
mm/memory.c
90
mm/memory.c
@ -2377,9 +2377,9 @@ static gfp_t __get_fault_gfp_mask(struct vm_area_struct *vma)
|
||||
*
|
||||
* We do this without the lock held, so that it can sleep if it needs to.
|
||||
*/
|
||||
static int do_page_mkwrite(struct vm_fault *vmf)
|
||||
static vm_fault_t do_page_mkwrite(struct vm_fault *vmf)
|
||||
{
|
||||
int ret;
|
||||
vm_fault_t ret;
|
||||
struct page *page = vmf->page;
|
||||
unsigned int old_flags = vmf->flags;
|
||||
|
||||
@ -2483,7 +2483,7 @@ static inline void wp_page_reuse(struct vm_fault *vmf)
|
||||
* held to the old page, as well as updating the rmap.
|
||||
* - In any case, unlock the PTL and drop the reference we took to the old page.
|
||||
*/
|
||||
static int wp_page_copy(struct vm_fault *vmf)
|
||||
static vm_fault_t wp_page_copy(struct vm_fault *vmf)
|
||||
{
|
||||
struct vm_area_struct *vma = vmf->vma;
|
||||
struct mm_struct *mm = vma->vm_mm;
|
||||
@ -2631,7 +2631,7 @@ oom:
|
||||
* The function expects the page to be locked or other protection against
|
||||
* concurrent faults / writeback (such as DAX radix tree locks).
|
||||
*/
|
||||
int finish_mkwrite_fault(struct vm_fault *vmf)
|
||||
vm_fault_t finish_mkwrite_fault(struct vm_fault *vmf)
|
||||
{
|
||||
WARN_ON_ONCE(!(vmf->vma->vm_flags & VM_SHARED));
|
||||
vmf->pte = pte_offset_map_lock(vmf->vma->vm_mm, vmf->pmd, vmf->address,
|
||||
@ -2652,12 +2652,12 @@ int finish_mkwrite_fault(struct vm_fault *vmf)
|
||||
* Handle write page faults for VM_MIXEDMAP or VM_PFNMAP for a VM_SHARED
|
||||
* mapping
|
||||
*/
|
||||
static int wp_pfn_shared(struct vm_fault *vmf)
|
||||
static vm_fault_t wp_pfn_shared(struct vm_fault *vmf)
|
||||
{
|
||||
struct vm_area_struct *vma = vmf->vma;
|
||||
|
||||
if (vma->vm_ops && vma->vm_ops->pfn_mkwrite) {
|
||||
int ret;
|
||||
vm_fault_t ret;
|
||||
|
||||
pte_unmap_unlock(vmf->pte, vmf->ptl);
|
||||
vmf->flags |= FAULT_FLAG_MKWRITE;
|
||||
@ -2670,7 +2670,7 @@ static int wp_pfn_shared(struct vm_fault *vmf)
|
||||
return VM_FAULT_WRITE;
|
||||
}
|
||||
|
||||
static int wp_page_shared(struct vm_fault *vmf)
|
||||
static vm_fault_t wp_page_shared(struct vm_fault *vmf)
|
||||
__releases(vmf->ptl)
|
||||
{
|
||||
struct vm_area_struct *vma = vmf->vma;
|
||||
@ -2678,7 +2678,7 @@ static int wp_page_shared(struct vm_fault *vmf)
|
||||
get_page(vmf->page);
|
||||
|
||||
if (vma->vm_ops && vma->vm_ops->page_mkwrite) {
|
||||
int tmp;
|
||||
vm_fault_t tmp;
|
||||
|
||||
pte_unmap_unlock(vmf->pte, vmf->ptl);
|
||||
tmp = do_page_mkwrite(vmf);
|
||||
@ -2721,7 +2721,7 @@ static int wp_page_shared(struct vm_fault *vmf)
|
||||
* but allow concurrent faults), with pte both mapped and locked.
|
||||
* We return with mmap_sem still held, but pte unmapped and unlocked.
|
||||
*/
|
||||
static int do_wp_page(struct vm_fault *vmf)
|
||||
static vm_fault_t do_wp_page(struct vm_fault *vmf)
|
||||
__releases(vmf->ptl)
|
||||
{
|
||||
struct vm_area_struct *vma = vmf->vma;
|
||||
@ -2897,7 +2897,7 @@ EXPORT_SYMBOL(unmap_mapping_range);
|
||||
* We return with the mmap_sem locked or unlocked in the same cases
|
||||
* as does filemap_fault().
|
||||
*/
|
||||
int do_swap_page(struct vm_fault *vmf)
|
||||
vm_fault_t do_swap_page(struct vm_fault *vmf)
|
||||
{
|
||||
struct vm_area_struct *vma = vmf->vma;
|
||||
struct page *page = NULL, *swapcache;
|
||||
@ -2906,7 +2906,7 @@ int do_swap_page(struct vm_fault *vmf)
|
||||
pte_t pte;
|
||||
int locked;
|
||||
int exclusive = 0;
|
||||
int ret = 0;
|
||||
vm_fault_t ret = 0;
|
||||
|
||||
if (!pte_unmap_same(vma->vm_mm, vmf->pmd, vmf->pte, vmf->orig_pte))
|
||||
goto out;
|
||||
@ -3117,12 +3117,12 @@ out_release:
|
||||
* but allow concurrent faults), and pte mapped but not yet locked.
|
||||
* We return with mmap_sem still held, but pte unmapped and unlocked.
|
||||
*/
|
||||
static int do_anonymous_page(struct vm_fault *vmf)
|
||||
static vm_fault_t do_anonymous_page(struct vm_fault *vmf)
|
||||
{
|
||||
struct vm_area_struct *vma = vmf->vma;
|
||||
struct mem_cgroup *memcg;
|
||||
struct page *page;
|
||||
int ret = 0;
|
||||
vm_fault_t ret = 0;
|
||||
pte_t entry;
|
||||
|
||||
/* File mapping without ->vm_ops ? */
|
||||
@ -3232,10 +3232,10 @@ oom:
|
||||
* released depending on flags and vma->vm_ops->fault() return value.
|
||||
* See filemap_fault() and __lock_page_retry().
|
||||
*/
|
||||
static int __do_fault(struct vm_fault *vmf)
|
||||
static vm_fault_t __do_fault(struct vm_fault *vmf)
|
||||
{
|
||||
struct vm_area_struct *vma = vmf->vma;
|
||||
int ret;
|
||||
vm_fault_t ret;
|
||||
|
||||
ret = vma->vm_ops->fault(vmf);
|
||||
if (unlikely(ret & (VM_FAULT_ERROR | VM_FAULT_NOPAGE | VM_FAULT_RETRY |
|
||||
@ -3269,7 +3269,7 @@ static int pmd_devmap_trans_unstable(pmd_t *pmd)
|
||||
return pmd_devmap(*pmd) || pmd_trans_unstable(pmd);
|
||||
}
|
||||
|
||||
static int pte_alloc_one_map(struct vm_fault *vmf)
|
||||
static vm_fault_t pte_alloc_one_map(struct vm_fault *vmf)
|
||||
{
|
||||
struct vm_area_struct *vma = vmf->vma;
|
||||
|
||||
@ -3345,13 +3345,14 @@ static void deposit_prealloc_pte(struct vm_fault *vmf)
|
||||
vmf->prealloc_pte = NULL;
|
||||
}
|
||||
|
||||
static int do_set_pmd(struct vm_fault *vmf, struct page *page)
|
||||
static vm_fault_t do_set_pmd(struct vm_fault *vmf, struct page *page)
|
||||
{
|
||||
struct vm_area_struct *vma = vmf->vma;
|
||||
bool write = vmf->flags & FAULT_FLAG_WRITE;
|
||||
unsigned long haddr = vmf->address & HPAGE_PMD_MASK;
|
||||
pmd_t entry;
|
||||
int i, ret;
|
||||
int i;
|
||||
vm_fault_t ret;
|
||||
|
||||
if (!transhuge_vma_suitable(vma, haddr))
|
||||
return VM_FAULT_FALLBACK;
|
||||
@ -3401,7 +3402,7 @@ out:
|
||||
return ret;
|
||||
}
|
||||
#else
|
||||
static int do_set_pmd(struct vm_fault *vmf, struct page *page)
|
||||
static vm_fault_t do_set_pmd(struct vm_fault *vmf, struct page *page)
|
||||
{
|
||||
BUILD_BUG();
|
||||
return 0;
|
||||
@ -3422,13 +3423,13 @@ static int do_set_pmd(struct vm_fault *vmf, struct page *page)
|
||||
* Target users are page handler itself and implementations of
|
||||
* vm_ops->map_pages.
|
||||
*/
|
||||
int alloc_set_pte(struct vm_fault *vmf, struct mem_cgroup *memcg,
|
||||
vm_fault_t alloc_set_pte(struct vm_fault *vmf, struct mem_cgroup *memcg,
|
||||
struct page *page)
|
||||
{
|
||||
struct vm_area_struct *vma = vmf->vma;
|
||||
bool write = vmf->flags & FAULT_FLAG_WRITE;
|
||||
pte_t entry;
|
||||
int ret;
|
||||
vm_fault_t ret;
|
||||
|
||||
if (pmd_none(*vmf->pmd) && PageTransCompound(page) &&
|
||||
IS_ENABLED(CONFIG_TRANSPARENT_HUGE_PAGECACHE)) {
|
||||
@ -3487,10 +3488,10 @@ int alloc_set_pte(struct vm_fault *vmf, struct mem_cgroup *memcg,
|
||||
* The function expects the page to be locked and on success it consumes a
|
||||
* reference of a page being mapped (for the PTE which maps it).
|
||||
*/
|
||||
int finish_fault(struct vm_fault *vmf)
|
||||
vm_fault_t finish_fault(struct vm_fault *vmf)
|
||||
{
|
||||
struct page *page;
|
||||
int ret = 0;
|
||||
vm_fault_t ret = 0;
|
||||
|
||||
/* Did we COW the page? */
|
||||
if ((vmf->flags & FAULT_FLAG_WRITE) &&
|
||||
@ -3576,12 +3577,13 @@ late_initcall(fault_around_debugfs);
|
||||
* (and therefore to page order). This way it's easier to guarantee
|
||||
* that we don't cross page table boundaries.
|
||||
*/
|
||||
static int do_fault_around(struct vm_fault *vmf)
|
||||
static vm_fault_t do_fault_around(struct vm_fault *vmf)
|
||||
{
|
||||
unsigned long address = vmf->address, nr_pages, mask;
|
||||
pgoff_t start_pgoff = vmf->pgoff;
|
||||
pgoff_t end_pgoff;
|
||||
int off, ret = 0;
|
||||
int off;
|
||||
vm_fault_t ret = 0;
|
||||
|
||||
nr_pages = READ_ONCE(fault_around_bytes) >> PAGE_SHIFT;
|
||||
mask = ~(nr_pages * PAGE_SIZE - 1) & PAGE_MASK;
|
||||
@ -3631,10 +3633,10 @@ out:
|
||||
return ret;
|
||||
}
|
||||
|
||||
static int do_read_fault(struct vm_fault *vmf)
|
||||
static vm_fault_t do_read_fault(struct vm_fault *vmf)
|
||||
{
|
||||
struct vm_area_struct *vma = vmf->vma;
|
||||
int ret = 0;
|
||||
vm_fault_t ret = 0;
|
||||
|
||||
/*
|
||||
* Let's call ->map_pages() first and use ->fault() as fallback
|
||||
@ -3658,10 +3660,10 @@ static int do_read_fault(struct vm_fault *vmf)
|
||||
return ret;
|
||||
}
|
||||
|
||||
static int do_cow_fault(struct vm_fault *vmf)
|
||||
static vm_fault_t do_cow_fault(struct vm_fault *vmf)
|
||||
{
|
||||
struct vm_area_struct *vma = vmf->vma;
|
||||
int ret;
|
||||
vm_fault_t ret;
|
||||
|
||||
if (unlikely(anon_vma_prepare(vma)))
|
||||
return VM_FAULT_OOM;
|
||||
@ -3697,10 +3699,10 @@ uncharge_out:
|
||||
return ret;
|
||||
}
|
||||
|
||||
static int do_shared_fault(struct vm_fault *vmf)
|
||||
static vm_fault_t do_shared_fault(struct vm_fault *vmf)
|
||||
{
|
||||
struct vm_area_struct *vma = vmf->vma;
|
||||
int ret, tmp;
|
||||
vm_fault_t ret, tmp;
|
||||
|
||||
ret = __do_fault(vmf);
|
||||
if (unlikely(ret & (VM_FAULT_ERROR | VM_FAULT_NOPAGE | VM_FAULT_RETRY)))
|
||||
@ -3738,10 +3740,10 @@ static int do_shared_fault(struct vm_fault *vmf)
|
||||
* The mmap_sem may have been released depending on flags and our
|
||||
* return value. See filemap_fault() and __lock_page_or_retry().
|
||||
*/
|
||||
static int do_fault(struct vm_fault *vmf)
|
||||
static vm_fault_t do_fault(struct vm_fault *vmf)
|
||||
{
|
||||
struct vm_area_struct *vma = vmf->vma;
|
||||
int ret;
|
||||
vm_fault_t ret;
|
||||
|
||||
/* The VMA was not fully populated on mmap() or missing VM_DONTEXPAND */
|
||||
if (!vma->vm_ops->fault)
|
||||
@ -3776,7 +3778,7 @@ static int numa_migrate_prep(struct page *page, struct vm_area_struct *vma,
|
||||
return mpol_misplaced(page, vma, addr);
|
||||
}
|
||||
|
||||
static int do_numa_page(struct vm_fault *vmf)
|
||||
static vm_fault_t do_numa_page(struct vm_fault *vmf)
|
||||
{
|
||||
struct vm_area_struct *vma = vmf->vma;
|
||||
struct page *page = NULL;
|
||||
@ -3866,7 +3868,7 @@ out:
|
||||
return 0;
|
||||
}
|
||||
|
||||
static inline int create_huge_pmd(struct vm_fault *vmf)
|
||||
static inline vm_fault_t create_huge_pmd(struct vm_fault *vmf)
|
||||
{
|
||||
if (vma_is_anonymous(vmf->vma))
|
||||
return do_huge_pmd_anonymous_page(vmf);
|
||||
@ -3876,7 +3878,7 @@ static inline int create_huge_pmd(struct vm_fault *vmf)
|
||||
}
|
||||
|
||||
/* `inline' is required to avoid gcc 4.1.2 build error */
|
||||
static inline int wp_huge_pmd(struct vm_fault *vmf, pmd_t orig_pmd)
|
||||
static inline vm_fault_t wp_huge_pmd(struct vm_fault *vmf, pmd_t orig_pmd)
|
||||
{
|
||||
if (vma_is_anonymous(vmf->vma))
|
||||
return do_huge_pmd_wp_page(vmf, orig_pmd);
|
||||
@ -3895,7 +3897,7 @@ static inline bool vma_is_accessible(struct vm_area_struct *vma)
|
||||
return vma->vm_flags & (VM_READ | VM_EXEC | VM_WRITE);
|
||||
}
|
||||
|
||||
static int create_huge_pud(struct vm_fault *vmf)
|
||||
static vm_fault_t create_huge_pud(struct vm_fault *vmf)
|
||||
{
|
||||
#ifdef CONFIG_TRANSPARENT_HUGEPAGE
|
||||
/* No support for anonymous transparent PUD pages yet */
|
||||
@ -3907,7 +3909,7 @@ static int create_huge_pud(struct vm_fault *vmf)
|
||||
return VM_FAULT_FALLBACK;
|
||||
}
|
||||
|
||||
static int wp_huge_pud(struct vm_fault *vmf, pud_t orig_pud)
|
||||
static vm_fault_t wp_huge_pud(struct vm_fault *vmf, pud_t orig_pud)
|
||||
{
|
||||
#ifdef CONFIG_TRANSPARENT_HUGEPAGE
|
||||
/* No support for anonymous transparent PUD pages yet */
|
||||
@ -3934,7 +3936,7 @@ static int wp_huge_pud(struct vm_fault *vmf, pud_t orig_pud)
|
||||
* The mmap_sem may have been released depending on flags and our return value.
|
||||
* See filemap_fault() and __lock_page_or_retry().
|
||||
*/
|
||||
static int handle_pte_fault(struct vm_fault *vmf)
|
||||
static vm_fault_t handle_pte_fault(struct vm_fault *vmf)
|
||||
{
|
||||
pte_t entry;
|
||||
|
||||
@ -4022,8 +4024,8 @@ unlock:
|
||||
* The mmap_sem may have been released depending on flags and our
|
||||
* return value. See filemap_fault() and __lock_page_or_retry().
|
||||
*/
|
||||
static int __handle_mm_fault(struct vm_area_struct *vma, unsigned long address,
|
||||
unsigned int flags)
|
||||
static vm_fault_t __handle_mm_fault(struct vm_area_struct *vma,
|
||||
unsigned long address, unsigned int flags)
|
||||
{
|
||||
struct vm_fault vmf = {
|
||||
.vma = vma,
|
||||
@ -4036,7 +4038,7 @@ static int __handle_mm_fault(struct vm_area_struct *vma, unsigned long address,
|
||||
struct mm_struct *mm = vma->vm_mm;
|
||||
pgd_t *pgd;
|
||||
p4d_t *p4d;
|
||||
int ret;
|
||||
vm_fault_t ret;
|
||||
|
||||
pgd = pgd_offset(mm, address);
|
||||
p4d = p4d_alloc(mm, pgd, address);
|
||||
@ -4111,10 +4113,10 @@ static int __handle_mm_fault(struct vm_area_struct *vma, unsigned long address,
|
||||
* The mmap_sem may have been released depending on flags and our
|
||||
* return value. See filemap_fault() and __lock_page_or_retry().
|
||||
*/
|
||||
int handle_mm_fault(struct vm_area_struct *vma, unsigned long address,
|
||||
vm_fault_t handle_mm_fault(struct vm_area_struct *vma, unsigned long address,
|
||||
unsigned int flags)
|
||||
{
|
||||
int ret;
|
||||
vm_fault_t ret;
|
||||
|
||||
__set_current_state(TASK_RUNNING);
|
||||
|
||||
|
||||
@ -1212,7 +1212,7 @@ out:
|
||||
* intentionally. Although it's rather weird,
|
||||
* it's how HWPoison flag works at the moment.
|
||||
*/
|
||||
if (!test_set_page_hwpoison(page))
|
||||
if (set_hwpoison_free_buddy_page(page))
|
||||
num_poisoned_pages_inc();
|
||||
}
|
||||
} else {
|
||||
@ -1331,8 +1331,6 @@ put_anon:
|
||||
out:
|
||||
if (rc != -EAGAIN)
|
||||
putback_active_hugepage(hpage);
|
||||
if (reason == MR_MEMORY_FAILURE && !test_set_page_hwpoison(hpage))
|
||||
num_poisoned_pages_inc();
|
||||
|
||||
/*
|
||||
* If migration was not successful and there's a freeing callback, use
|
||||
|
||||
@ -8096,3 +8096,33 @@ bool is_free_buddy_page(struct page *page)
|
||||
|
||||
return order < MAX_ORDER;
|
||||
}
|
||||
|
||||
#ifdef CONFIG_MEMORY_FAILURE
|
||||
/*
|
||||
* Set PG_hwpoison flag if a given page is confirmed to be a free page. This
|
||||
* test is performed under the zone lock to prevent a race against page
|
||||
* allocation.
|
||||
*/
|
||||
bool set_hwpoison_free_buddy_page(struct page *page)
|
||||
{
|
||||
struct zone *zone = page_zone(page);
|
||||
unsigned long pfn = page_to_pfn(page);
|
||||
unsigned long flags;
|
||||
unsigned int order;
|
||||
bool hwpoisoned = false;
|
||||
|
||||
spin_lock_irqsave(&zone->lock, flags);
|
||||
for (order = 0; order < MAX_ORDER; order++) {
|
||||
struct page *page_head = page - (pfn & ((1 << order) - 1));
|
||||
|
||||
if (PageBuddy(page_head) && page_order(page_head) >= order) {
|
||||
if (!TestSetPageHWPoison(page))
|
||||
hwpoisoned = true;
|
||||
break;
|
||||
}
|
||||
}
|
||||
spin_unlock_irqrestore(&zone->lock, flags);
|
||||
|
||||
return hwpoisoned;
|
||||
}
|
||||
#endif
|
||||
|
||||
@ -124,7 +124,7 @@ static int shmem_replace_page(struct page **pagep, gfp_t gfp,
|
||||
static int shmem_getpage_gfp(struct inode *inode, pgoff_t index,
|
||||
struct page **pagep, enum sgp_type sgp,
|
||||
gfp_t gfp, struct vm_area_struct *vma,
|
||||
struct vm_fault *vmf, int *fault_type);
|
||||
struct vm_fault *vmf, vm_fault_t *fault_type);
|
||||
|
||||
int shmem_getpage(struct inode *inode, pgoff_t index,
|
||||
struct page **pagep, enum sgp_type sgp)
|
||||
@ -1620,7 +1620,8 @@ static int shmem_replace_page(struct page **pagep, gfp_t gfp,
|
||||
*/
|
||||
static int shmem_getpage_gfp(struct inode *inode, pgoff_t index,
|
||||
struct page **pagep, enum sgp_type sgp, gfp_t gfp,
|
||||
struct vm_area_struct *vma, struct vm_fault *vmf, int *fault_type)
|
||||
struct vm_area_struct *vma, struct vm_fault *vmf,
|
||||
vm_fault_t *fault_type)
|
||||
{
|
||||
struct address_space *mapping = inode->i_mapping;
|
||||
struct shmem_inode_info *info = SHMEM_I(inode);
|
||||
|
||||
@ -196,7 +196,7 @@ void *vmemdup_user(const void __user *src, size_t len)
|
||||
}
|
||||
EXPORT_SYMBOL(vmemdup_user);
|
||||
|
||||
/*
|
||||
/**
|
||||
* strndup_user - duplicate an existing string from user space
|
||||
* @s: The string to duplicate
|
||||
* @n: Maximum number of bytes to copy, including the trailing NUL.
|
||||
@ -434,6 +434,13 @@ void *kvmalloc_node(size_t size, gfp_t flags, int node)
|
||||
}
|
||||
EXPORT_SYMBOL(kvmalloc_node);
|
||||
|
||||
/**
|
||||
* kvfree - free memory allocated with kvmalloc
|
||||
* @addr: pointer returned by kvmalloc
|
||||
*
|
||||
* If the memory is allocated from vmalloc area it is freed with vfree().
|
||||
* Otherwise kfree() is used.
|
||||
*/
|
||||
void kvfree(const void *addr)
|
||||
{
|
||||
if (is_vmalloc_addr(addr))
|
||||
|
||||
@ -296,10 +296,10 @@ config IP_VS_MH_TAB_INDEX
|
||||
stored in a hash table. This table is assigned by a preference
|
||||
list of the positions to each destination until all slots in
|
||||
the table are filled. The index determines the prime for size of
|
||||
the table as 251, 509, 1021, 2039, 4093, 8191, 16381, 32749,
|
||||
65521 or 131071. When using weights to allow destinations to
|
||||
receive more connections, the table is assigned an amount
|
||||
proportional to the weights specified. The table needs to be large
|
||||
the table as 251, 509, 1021, 2039, 4093, 8191, 16381, 32749,
|
||||
65521 or 131071. When using weights to allow destinations to
|
||||
receive more connections, the table is assigned an amount
|
||||
proportional to the weights specified. The table needs to be large
|
||||
enough to effectively fit all the destinations multiplied by their
|
||||
respective weights.
|
||||
|
||||
|
||||
@ -5,10 +5,10 @@
|
||||
*
|
||||
*/
|
||||
|
||||
/* The mh algorithm is to assign a preference list of all the lookup
|
||||
/* The mh algorithm is to assign a preference list of all the lookup
|
||||
* table positions to each destination and populate the table with
|
||||
* the most-preferred position of destinations. Then it is to select
|
||||
* destination with the hash key of source IP address through looking
|
||||
* destination with the hash key of source IP address through looking
|
||||
* up a the lookup table.
|
||||
*
|
||||
* The algorithm is detailed in:
|
||||
|
||||
@ -423,6 +423,7 @@ didnt||didn't
|
||||
diferent||different
|
||||
differrence||difference
|
||||
diffrent||different
|
||||
differenciate||differentiate
|
||||
diffrentiate||differentiate
|
||||
difinition||definition
|
||||
dimesions||dimensions
|
||||
@ -667,6 +668,7 @@ inofficial||unofficial
|
||||
inrerface||interface
|
||||
insititute||institute
|
||||
instal||install
|
||||
instanciate||instantiate
|
||||
instanciated||instantiated
|
||||
inteface||interface
|
||||
integreated||integrated
|
||||
|
||||
@ -153,7 +153,7 @@ struct sst_block_allocator {
|
||||
};
|
||||
|
||||
/*
|
||||
* Runtime Module Instance - A module object can be instanciated multiple
|
||||
* Runtime Module Instance - A module object can be instantiated multiple
|
||||
* times within the DSP FW.
|
||||
*/
|
||||
struct sst_module_runtime {
|
||||
@ -193,7 +193,7 @@ enum sst_module_state {
|
||||
*
|
||||
* Each Firmware file can consist of 1..N modules. A module can span multiple
|
||||
* ADSP memory blocks. The simplest FW will be a file with 1 module. A module
|
||||
* can be instanciated multiple times in the DSP.
|
||||
* can be instantiated multiple times in the DSP.
|
||||
*/
|
||||
struct sst_module {
|
||||
struct sst_dsp *dsp;
|
||||
|
||||
@ -323,12 +323,12 @@ msgstr " Hardwarebedingte Grenzen der Taktfrequenz: "
|
||||
#: utils/cpufreq-info.c:256
|
||||
#, c-format
|
||||
msgid " available frequency steps: "
|
||||
msgstr " mögliche Taktfrequenzen: "
|
||||
msgstr " mögliche Taktfrequenzen: "
|
||||
|
||||
#: utils/cpufreq-info.c:269
|
||||
#, c-format
|
||||
msgid " available cpufreq governors: "
|
||||
msgstr " mögliche Regler: "
|
||||
msgstr " mögliche Regler: "
|
||||
|
||||
#: utils/cpufreq-info.c:280
|
||||
#, c-format
|
||||
@ -381,7 +381,7 @@ msgstr "Optionen:\n"
|
||||
msgid " -e, --debug Prints out debug information [default]\n"
|
||||
msgstr ""
|
||||
" -e, --debug Erzeugt detaillierte Informationen, hilfreich\n"
|
||||
" zum Aufspüren von Fehlern\n"
|
||||
" zum Aufspüren von Fehlern\n"
|
||||
|
||||
#: utils/cpufreq-info.c:475
|
||||
#, c-format
|
||||
@ -424,7 +424,7 @@ msgstr " -p, --policy Findet die momentane Taktik heraus *\n"
|
||||
#: utils/cpufreq-info.c:482
|
||||
#, c-format
|
||||
msgid " -g, --governors Determines available cpufreq governors *\n"
|
||||
msgstr " -g, --governors Erzeugt eine Liste mit verfügbaren Reglern *\n"
|
||||
msgstr " -g, --governors Erzeugt eine Liste mit verfügbaren Reglern *\n"
|
||||
|
||||
#: utils/cpufreq-info.c:483
|
||||
#, c-format
|
||||
@ -450,7 +450,7 @@ msgstr ""
|
||||
#, c-format
|
||||
msgid " -s, --stats Shows cpufreq statistics if available\n"
|
||||
msgstr ""
|
||||
" -s, --stats Zeigt, sofern möglich, Statistiken über cpufreq an.\n"
|
||||
" -s, --stats Zeigt, sofern möglich, Statistiken über cpufreq an.\n"
|
||||
|
||||
#: utils/cpufreq-info.c:487
|
||||
#, c-format
|
||||
@ -473,9 +473,9 @@ msgid ""
|
||||
"cpufreq\n"
|
||||
" interface in 2.4. and early 2.6. kernels\n"
|
||||
msgstr ""
|
||||
" -o, --proc Erzeugt Informationen in einem ähnlichem Format zu "
|
||||
" -o, --proc Erzeugt Informationen in einem ähnlichem Format zu "
|
||||
"dem\n"
|
||||
" der /proc/cpufreq-Datei in 2.4. und frühen 2.6.\n"
|
||||
" der /proc/cpufreq-Datei in 2.4. und frühen 2.6.\n"
|
||||
" Kernel-Versionen\n"
|
||||
|
||||
#: utils/cpufreq-info.c:491
|
||||
@ -491,7 +491,7 @@ msgstr ""
|
||||
#: utils/cpufreq-info.c:492 utils/cpuidle-info.c:152
|
||||
#, c-format
|
||||
msgid " -h, --help Prints out this screen\n"
|
||||
msgstr " -h, --help Gibt diese Kurzübersicht aus\n"
|
||||
msgstr " -h, --help Gibt diese Kurzübersicht aus\n"
|
||||
|
||||
#: utils/cpufreq-info.c:495
|
||||
#, c-format
|
||||
@ -501,7 +501,7 @@ msgid ""
|
||||
msgstr ""
|
||||
"Sofern kein anderer Parameter als '-c, --cpu' angegeben wird, liefert "
|
||||
"dieses\n"
|
||||
"Programm Informationen, die z.B. zum Berichten von Fehlern nützlich sind.\n"
|
||||
"Programm Informationen, die z.B. zum Berichten von Fehlern nützlich sind.\n"
|
||||
|
||||
#: utils/cpufreq-info.c:497
|
||||
#, c-format
|
||||
@ -557,7 +557,7 @@ msgid ""
|
||||
"select\n"
|
||||
msgstr ""
|
||||
" -d FREQ, --min FREQ neue minimale Taktfrequenz, die der Regler\n"
|
||||
" auswählen darf\n"
|
||||
" auswählen darf\n"
|
||||
|
||||
#: utils/cpufreq-set.c:28
|
||||
#, c-format
|
||||
@ -566,7 +566,7 @@ msgid ""
|
||||
"select\n"
|
||||
msgstr ""
|
||||
" -u FREQ, --max FREQ neue maximale Taktfrequenz, die der Regler\n"
|
||||
" auswählen darf\n"
|
||||
" auswählen darf\n"
|
||||
|
||||
#: utils/cpufreq-set.c:29
|
||||
#, c-format
|
||||
@ -579,20 +579,20 @@ msgid ""
|
||||
" -f FREQ, --freq FREQ specific frequency to be set. Requires userspace\n"
|
||||
" governor to be available and loaded\n"
|
||||
msgstr ""
|
||||
" -f FREQ, --freq FREQ setze exakte Taktfrequenz. Benötigt den Regler\n"
|
||||
" -f FREQ, --freq FREQ setze exakte Taktfrequenz. Benötigt den Regler\n"
|
||||
" 'userspace'.\n"
|
||||
|
||||
#: utils/cpufreq-set.c:32
|
||||
#, c-format
|
||||
msgid " -r, --related Switches all hardware-related CPUs\n"
|
||||
msgstr ""
|
||||
" -r, --related Setze Werte für alle CPUs, deren Taktfrequenz\n"
|
||||
" -r, --related Setze Werte für alle CPUs, deren Taktfrequenz\n"
|
||||
" hardwarebedingt identisch ist.\n"
|
||||
|
||||
#: utils/cpufreq-set.c:33 utils/cpupower-set.c:28 utils/cpupower-info.c:27
|
||||
#, c-format
|
||||
msgid " -h, --help Prints out this screen\n"
|
||||
msgstr " -h, --help Gibt diese Kurzübersicht aus\n"
|
||||
msgstr " -h, --help Gibt diese Kurzübersicht aus\n"
|
||||
|
||||
#: utils/cpufreq-set.c:35
|
||||
#, fuzzy, c-format
|
||||
@ -618,8 +618,8 @@ msgstr ""
|
||||
" angenommen\n"
|
||||
"2. Der Parameter -f bzw. --freq kann mit keinem anderen als dem Parameter\n"
|
||||
" -c bzw. --cpu kombiniert werden\n"
|
||||
"3. FREQuenzen können in Hz, kHz (Standard), MHz, GHz oder THz eingegeben\n"
|
||||
" werden, indem der Wert und unmittelbar anschließend (ohne Leerzeichen!)\n"
|
||||
"3. FREQuenzen können in Hz, kHz (Standard), MHz, GHz oder THz eingegeben\n"
|
||||
" werden, indem der Wert und unmittelbar anschließend (ohne Leerzeichen!)\n"
|
||||
" die Einheit angegeben werden. (Bsp: 1GHz )\n"
|
||||
" (FREQuenz in kHz =^ MHz * 1000 =^ GHz * 1000000).\n"
|
||||
|
||||
@ -638,7 +638,7 @@ msgid ""
|
||||
msgstr ""
|
||||
"Beim Einstellen ist ein Fehler aufgetreten. Typische Fehlerquellen sind:\n"
|
||||
"- nicht ausreichende Rechte (Administrator)\n"
|
||||
"- der Regler ist nicht verfügbar bzw. nicht geladen\n"
|
||||
"- der Regler ist nicht verfügbar bzw. nicht geladen\n"
|
||||
"- die angegebene Taktik ist inkorrekt\n"
|
||||
"- eine spezifische Frequenz wurde angegeben, aber der Regler 'userspace'\n"
|
||||
" kann entweder hardwarebedingt nicht genutzt werden oder ist nicht geladen\n"
|
||||
@ -821,7 +821,7 @@ msgstr ""
|
||||
#: utils/cpuidle-info.c:48
|
||||
#, fuzzy, c-format
|
||||
msgid "Available idle states:"
|
||||
msgstr " mögliche Taktfrequenzen: "
|
||||
msgstr " mögliche Taktfrequenzen: "
|
||||
|
||||
#: utils/cpuidle-info.c:71
|
||||
#, c-format
|
||||
@ -924,7 +924,7 @@ msgstr "Aufruf: cpufreq-info [Optionen]\n"
|
||||
msgid " -s, --silent Only show general C-state information\n"
|
||||
msgstr ""
|
||||
" -e, --debug Erzeugt detaillierte Informationen, hilfreich\n"
|
||||
" zum Aufspüren von Fehlern\n"
|
||||
" zum Aufspüren von Fehlern\n"
|
||||
|
||||
#: utils/cpuidle-info.c:150
|
||||
#, fuzzy, c-format
|
||||
@ -933,9 +933,9 @@ msgid ""
|
||||
"acpi/processor/*/power\n"
|
||||
" interface in older kernels\n"
|
||||
msgstr ""
|
||||
" -o, --proc Erzeugt Informationen in einem ähnlichem Format zu "
|
||||
" -o, --proc Erzeugt Informationen in einem ähnlichem Format zu "
|
||||
"dem\n"
|
||||
" der /proc/cpufreq-Datei in 2.4. und frühen 2.6.\n"
|
||||
" der /proc/cpufreq-Datei in 2.4. und frühen 2.6.\n"
|
||||
" Kernel-Versionen\n"
|
||||
|
||||
#: utils/cpuidle-info.c:209
|
||||
@ -949,7 +949,7 @@ msgstr ""
|
||||
#~ " -c CPU, --cpu CPU CPU number which information shall be determined "
|
||||
#~ "about\n"
|
||||
#~ msgstr ""
|
||||
#~ " -c CPU, --cpu CPU Nummer der CPU, über die Informationen "
|
||||
#~ " -c CPU, --cpu CPU Nummer der CPU, über die Informationen "
|
||||
#~ "herausgefunden werden sollen\n"
|
||||
|
||||
#~ msgid ""
|
||||
|
||||
@ -212,7 +212,7 @@ msgstr ""
|
||||
#: utils/cpupower.c:91
|
||||
#, c-format
|
||||
msgid "Report errors and bugs to %s, please.\n"
|
||||
msgstr "Veuillez rapportez les erreurs et les bogues à %s, s'il vous plait.\n"
|
||||
msgstr "Veuillez rapportez les erreurs et les bogues à %s, s'il vous plait.\n"
|
||||
|
||||
#: utils/cpupower.c:114
|
||||
#, c-format
|
||||
@ -227,14 +227,14 @@ msgstr ""
|
||||
#: utils/cpufreq-info.c:31
|
||||
#, c-format
|
||||
msgid "Couldn't count the number of CPUs (%s: %s), assuming 1\n"
|
||||
msgstr "Détermination du nombre de CPUs (%s : %s) impossible. Assume 1\n"
|
||||
msgstr "Détermination du nombre de CPUs (%s : %s) impossible. Assume 1\n"
|
||||
|
||||
#: utils/cpufreq-info.c:63
|
||||
#, c-format
|
||||
msgid ""
|
||||
" minimum CPU frequency - maximum CPU frequency - governor\n"
|
||||
msgstr ""
|
||||
" Fréquence CPU minimale - Fréquence CPU maximale - régulateur\n"
|
||||
" Fréquence CPU minimale - Fréquence CPU maximale - régulateur\n"
|
||||
|
||||
#: utils/cpufreq-info.c:151
|
||||
#, c-format
|
||||
@ -302,12 +302,12 @@ msgstr " pilote : %s\n"
|
||||
#: utils/cpufreq-info.c:219
|
||||
#, fuzzy, c-format
|
||||
msgid " CPUs which run at the same hardware frequency: "
|
||||
msgstr " CPUs qui doivent changer de fréquences en même temps : "
|
||||
msgstr " CPUs qui doivent changer de fréquences en même temps : "
|
||||
|
||||
#: utils/cpufreq-info.c:230
|
||||
#, fuzzy, c-format
|
||||
msgid " CPUs which need to have their frequency coordinated by software: "
|
||||
msgstr " CPUs qui doivent changer de fréquences en même temps : "
|
||||
msgstr " CPUs qui doivent changer de fréquences en même temps : "
|
||||
|
||||
#: utils/cpufreq-info.c:241
|
||||
#, c-format
|
||||
@ -317,22 +317,22 @@ msgstr ""
|
||||
#: utils/cpufreq-info.c:247
|
||||
#, c-format
|
||||
msgid " hardware limits: "
|
||||
msgstr " limitation matérielle : "
|
||||
msgstr " limitation matérielle : "
|
||||
|
||||
#: utils/cpufreq-info.c:256
|
||||
#, c-format
|
||||
msgid " available frequency steps: "
|
||||
msgstr " plage de fréquence : "
|
||||
msgstr " plage de fréquence : "
|
||||
|
||||
#: utils/cpufreq-info.c:269
|
||||
#, c-format
|
||||
msgid " available cpufreq governors: "
|
||||
msgstr " régulateurs disponibles : "
|
||||
msgstr " régulateurs disponibles : "
|
||||
|
||||
#: utils/cpufreq-info.c:280
|
||||
#, c-format
|
||||
msgid " current policy: frequency should be within "
|
||||
msgstr " tactique actuelle : la fréquence doit être comprise entre "
|
||||
msgstr " tactique actuelle : la fréquence doit être comprise entre "
|
||||
|
||||
#: utils/cpufreq-info.c:282
|
||||
#, c-format
|
||||
@ -345,18 +345,18 @@ msgid ""
|
||||
"The governor \"%s\" may decide which speed to use\n"
|
||||
" within this range.\n"
|
||||
msgstr ""
|
||||
"Le régulateur \"%s\" est libre de choisir la vitesse\n"
|
||||
" dans cette plage de fréquences.\n"
|
||||
"Le régulateur \"%s\" est libre de choisir la vitesse\n"
|
||||
" dans cette plage de fréquences.\n"
|
||||
|
||||
#: utils/cpufreq-info.c:293
|
||||
#, c-format
|
||||
msgid " current CPU frequency is "
|
||||
msgstr " la fréquence actuelle de ce CPU est "
|
||||
msgstr " la fréquence actuelle de ce CPU est "
|
||||
|
||||
#: utils/cpufreq-info.c:296
|
||||
#, c-format
|
||||
msgid " (asserted by call to hardware)"
|
||||
msgstr " (vérifié par un appel direct du matériel)"
|
||||
msgstr " (vérifié par un appel direct du matériel)"
|
||||
|
||||
#: utils/cpufreq-info.c:304
|
||||
#, c-format
|
||||
@ -377,7 +377,7 @@ msgstr "Options :\n"
|
||||
#: utils/cpufreq-info.c:474
|
||||
#, fuzzy, c-format
|
||||
msgid " -e, --debug Prints out debug information [default]\n"
|
||||
msgstr " -e, --debug Afficher les informations de déboguage\n"
|
||||
msgstr " -e, --debug Afficher les informations de déboguage\n"
|
||||
|
||||
#: utils/cpufreq-info.c:475
|
||||
#, c-format
|
||||
@ -385,8 +385,8 @@ msgid ""
|
||||
" -f, --freq Get frequency the CPU currently runs at, according\n"
|
||||
" to the cpufreq core *\n"
|
||||
msgstr ""
|
||||
" -f, --freq Obtenir la fréquence actuelle du CPU selon le point\n"
|
||||
" de vue du coeur du système de cpufreq *\n"
|
||||
" -f, --freq Obtenir la fréquence actuelle du CPU selon le point\n"
|
||||
" de vue du coeur du système de cpufreq *\n"
|
||||
|
||||
#: utils/cpufreq-info.c:477
|
||||
#, c-format
|
||||
@ -394,8 +394,8 @@ msgid ""
|
||||
" -w, --hwfreq Get frequency the CPU currently runs at, by reading\n"
|
||||
" it from hardware (only available to root) *\n"
|
||||
msgstr ""
|
||||
" -w, --hwfreq Obtenir la fréquence actuelle du CPU directement par\n"
|
||||
" le matériel (doit être root) *\n"
|
||||
" -w, --hwfreq Obtenir la fréquence actuelle du CPU directement par\n"
|
||||
" le matériel (doit être root) *\n"
|
||||
|
||||
#: utils/cpufreq-info.c:479
|
||||
#, c-format
|
||||
@ -403,13 +403,13 @@ msgid ""
|
||||
" -l, --hwlimits Determine the minimum and maximum CPU frequency "
|
||||
"allowed *\n"
|
||||
msgstr ""
|
||||
" -l, --hwlimits Affiche les fréquences minimales et maximales du CPU "
|
||||
" -l, --hwlimits Affiche les fréquences minimales et maximales du CPU "
|
||||
"*\n"
|
||||
|
||||
#: utils/cpufreq-info.c:480
|
||||
#, c-format
|
||||
msgid " -d, --driver Determines the used cpufreq kernel driver *\n"
|
||||
msgstr " -d, --driver Affiche le pilote cpufreq utilisé *\n"
|
||||
msgstr " -d, --driver Affiche le pilote cpufreq utilisé *\n"
|
||||
|
||||
#: utils/cpufreq-info.c:481
|
||||
#, c-format
|
||||
@ -420,7 +420,7 @@ msgstr " -p, --policy Affiche la tactique actuelle de cpufreq *\n"
|
||||
#, c-format
|
||||
msgid " -g, --governors Determines available cpufreq governors *\n"
|
||||
msgstr ""
|
||||
" -g, --governors Affiche les régulateurs disponibles de cpufreq *\n"
|
||||
" -g, --governors Affiche les régulateurs disponibles de cpufreq *\n"
|
||||
|
||||
#: utils/cpufreq-info.c:483
|
||||
#, fuzzy, c-format
|
||||
@ -429,7 +429,7 @@ msgid ""
|
||||
"frequency *\n"
|
||||
msgstr ""
|
||||
" -a, --affected-cpus Affiche quels sont les CPUs qui doivent changer de\n"
|
||||
" fréquences en même temps *\n"
|
||||
" fréquences en même temps *\n"
|
||||
|
||||
#: utils/cpufreq-info.c:484
|
||||
#, fuzzy, c-format
|
||||
@ -438,7 +438,7 @@ msgid ""
|
||||
" coordinated by software *\n"
|
||||
msgstr ""
|
||||
" -a, --affected-cpus Affiche quels sont les CPUs qui doivent changer de\n"
|
||||
" fréquences en même temps *\n"
|
||||
" fréquences en même temps *\n"
|
||||
|
||||
#: utils/cpufreq-info.c:486
|
||||
#, c-format
|
||||
@ -453,7 +453,7 @@ msgid ""
|
||||
" -y, --latency Determines the maximum latency on CPU frequency "
|
||||
"changes *\n"
|
||||
msgstr ""
|
||||
" -l, --hwlimits Affiche les fréquences minimales et maximales du CPU "
|
||||
" -l, --hwlimits Affiche les fréquences minimales et maximales du CPU "
|
||||
"*\n"
|
||||
|
||||
#: utils/cpufreq-info.c:488
|
||||
@ -469,7 +469,7 @@ msgid ""
|
||||
" interface in 2.4. and early 2.6. kernels\n"
|
||||
msgstr ""
|
||||
" -o, --proc Affiche les informations en utilisant l'interface\n"
|
||||
" fournie par /proc/cpufreq, présente dans les "
|
||||
" fournie par /proc/cpufreq, présente dans les "
|
||||
"versions\n"
|
||||
" 2.4 et les anciennes versions 2.6 du noyau\n"
|
||||
|
||||
@ -485,7 +485,7 @@ msgstr ""
|
||||
#: utils/cpufreq-info.c:492 utils/cpuidle-info.c:152
|
||||
#, c-format
|
||||
msgid " -h, --help Prints out this screen\n"
|
||||
msgstr " -h, --help affiche l'aide-mémoire\n"
|
||||
msgstr " -h, --help affiche l'aide-mémoire\n"
|
||||
|
||||
#: utils/cpufreq-info.c:495
|
||||
#, c-format
|
||||
@ -493,8 +493,8 @@ msgid ""
|
||||
"If no argument or only the -c, --cpu parameter is given, debug output about\n"
|
||||
"cpufreq is printed which is useful e.g. for reporting bugs.\n"
|
||||
msgstr ""
|
||||
"Par défaut, les informations de déboguage seront affichées si aucun\n"
|
||||
"argument, ou bien si seulement l'argument -c (--cpu) est donné, afin de\n"
|
||||
"Par défaut, les informations de déboguage seront affichées si aucun\n"
|
||||
"argument, ou bien si seulement l'argument -c (--cpu) est donné, afin de\n"
|
||||
"faciliter les rapports de bogues par exemple\n"
|
||||
|
||||
#: utils/cpufreq-info.c:497
|
||||
@ -517,8 +517,8 @@ msgid ""
|
||||
"You can't specify more than one --cpu parameter and/or\n"
|
||||
"more than one output-specific argument\n"
|
||||
msgstr ""
|
||||
"On ne peut indiquer plus d'un paramètre --cpu, tout comme l'on ne peut\n"
|
||||
"spécifier plus d'un argument de formatage\n"
|
||||
"On ne peut indiquer plus d'un paramètre --cpu, tout comme l'on ne peut\n"
|
||||
"spécifier plus d'un argument de formatage\n"
|
||||
|
||||
#: utils/cpufreq-info.c:600 utils/cpufreq-set.c:82 utils/cpupower-set.c:42
|
||||
#: utils/cpupower-info.c:42 utils/cpuidle-info.c:213
|
||||
@ -529,7 +529,7 @@ msgstr "option invalide\n"
|
||||
#: utils/cpufreq-info.c:617
|
||||
#, c-format
|
||||
msgid "couldn't analyze CPU %d as it doesn't seem to be present\n"
|
||||
msgstr "analyse du CPU %d impossible puisqu'il ne semble pas être présent\n"
|
||||
msgstr "analyse du CPU %d impossible puisqu'il ne semble pas être présent\n"
|
||||
|
||||
#: utils/cpufreq-info.c:620 utils/cpupower-info.c:142
|
||||
#, c-format
|
||||
@ -547,8 +547,8 @@ msgid ""
|
||||
" -d FREQ, --min FREQ new minimum CPU frequency the governor may "
|
||||
"select\n"
|
||||
msgstr ""
|
||||
" -d FREQ, --min FREQ nouvelle fréquence minimale du CPU à utiliser\n"
|
||||
" par le régulateur\n"
|
||||
" -d FREQ, --min FREQ nouvelle fréquence minimale du CPU à utiliser\n"
|
||||
" par le régulateur\n"
|
||||
|
||||
#: utils/cpufreq-set.c:28
|
||||
#, c-format
|
||||
@ -556,13 +556,13 @@ msgid ""
|
||||
" -u FREQ, --max FREQ new maximum CPU frequency the governor may "
|
||||
"select\n"
|
||||
msgstr ""
|
||||
" -u FREQ, --max FREQ nouvelle fréquence maximale du CPU à utiliser\n"
|
||||
" par le régulateur\n"
|
||||
" -u FREQ, --max FREQ nouvelle fréquence maximale du CPU à utiliser\n"
|
||||
" par le régulateur\n"
|
||||
|
||||
#: utils/cpufreq-set.c:29
|
||||
#, c-format
|
||||
msgid " -g GOV, --governor GOV new cpufreq governor\n"
|
||||
msgstr " -g GOV, --governor GOV active le régulateur GOV\n"
|
||||
msgstr " -g GOV, --governor GOV active le régulateur GOV\n"
|
||||
|
||||
#: utils/cpufreq-set.c:30
|
||||
#, c-format
|
||||
@ -570,9 +570,9 @@ msgid ""
|
||||
" -f FREQ, --freq FREQ specific frequency to be set. Requires userspace\n"
|
||||
" governor to be available and loaded\n"
|
||||
msgstr ""
|
||||
" -f FREQ, --freq FREQ fixe la fréquence du processeur à FREQ. Il faut\n"
|
||||
" que le régulateur « userspace » soit disponible \n"
|
||||
" et activé.\n"
|
||||
" -f FREQ, --freq FREQ fixe la fréquence du processeur à FREQ. Il faut\n"
|
||||
" que le régulateur « userspace » soit disponible \n"
|
||||
" et activé.\n"
|
||||
|
||||
#: utils/cpufreq-set.c:32
|
||||
#, c-format
|
||||
@ -582,7 +582,7 @@ msgstr ""
|
||||
#: utils/cpufreq-set.c:33 utils/cpupower-set.c:28 utils/cpupower-info.c:27
|
||||
#, fuzzy, c-format
|
||||
msgid " -h, --help Prints out this screen\n"
|
||||
msgstr " -h, --help affiche l'aide-mémoire\n"
|
||||
msgstr " -h, --help affiche l'aide-mémoire\n"
|
||||
|
||||
#: utils/cpufreq-set.c:35
|
||||
#, fuzzy, c-format
|
||||
@ -602,11 +602,11 @@ msgid ""
|
||||
" (FREQuency in kHz =^ Hz * 0.001 =^ MHz * 1000 =^ GHz * 1000000).\n"
|
||||
msgstr ""
|
||||
"Remarque :\n"
|
||||
"1. Le CPU numéro 0 sera utilisé par défaut si -c (ou --cpu) est omis ;\n"
|
||||
"2. l'argument -f FREQ (ou --freq FREQ) ne peut être utilisé qu'avec --cpu ;\n"
|
||||
"3. on pourra préciser l'unité des fréquences en postfixant sans aucune "
|
||||
"1. Le CPU numéro 0 sera utilisé par défaut si -c (ou --cpu) est omis ;\n"
|
||||
"2. l'argument -f FREQ (ou --freq FREQ) ne peut être utilisé qu'avec --cpu ;\n"
|
||||
"3. on pourra préciser l'unité des fréquences en postfixant sans aucune "
|
||||
"espace\n"
|
||||
" les valeurs par hz, kHz (par défaut), MHz, GHz ou THz\n"
|
||||
" les valeurs par hz, kHz (par défaut), MHz, GHz ou THz\n"
|
||||
" (kHz =^ Hz * 0.001 =^ MHz * 1000 =^ GHz * 1000000).\n"
|
||||
|
||||
#: utils/cpufreq-set.c:57
|
||||
@ -622,21 +622,21 @@ msgid ""
|
||||
"frequency\n"
|
||||
" or because the userspace governor isn't loaded?\n"
|
||||
msgstr ""
|
||||
"En ajustant les nouveaux paramètres, une erreur est apparue. Les sources\n"
|
||||
"En ajustant les nouveaux paramètres, une erreur est apparue. Les sources\n"
|
||||
"d'erreur typique sont :\n"
|
||||
"- droit d'administration insuffisant (êtes-vous root ?) ;\n"
|
||||
"- le régulateur choisi n'est pas disponible, ou bien n'est pas disponible "
|
||||
"- droit d'administration insuffisant (êtes-vous root ?) ;\n"
|
||||
"- le régulateur choisi n'est pas disponible, ou bien n'est pas disponible "
|
||||
"en\n"
|
||||
" tant que module noyau ;\n"
|
||||
"- la tactique n'est pas disponible ;\n"
|
||||
"- vous voulez utiliser l'option -f/--freq, mais le régulateur « userspace »\n"
|
||||
" n'est pas disponible, par exemple parce que le matériel ne le supporte\n"
|
||||
" pas, ou bien n'est tout simplement pas chargé.\n"
|
||||
"- vous voulez utiliser l'option -f/--freq, mais le régulateur « userspace »\n"
|
||||
" n'est pas disponible, par exemple parce que le matériel ne le supporte\n"
|
||||
" pas, ou bien n'est tout simplement pas chargé.\n"
|
||||
|
||||
#: utils/cpufreq-set.c:170
|
||||
#, c-format
|
||||
msgid "wrong, unknown or unhandled CPU?\n"
|
||||
msgstr "CPU inconnu ou non supporté ?\n"
|
||||
msgstr "CPU inconnu ou non supporté ?\n"
|
||||
|
||||
#: utils/cpufreq-set.c:302
|
||||
#, c-format
|
||||
@ -653,7 +653,7 @@ msgid ""
|
||||
"At least one parameter out of -f/--freq, -d/--min, -u/--max, and\n"
|
||||
"-g/--governor must be passed\n"
|
||||
msgstr ""
|
||||
"L'un de ces paramètres est obligatoire : -f/--freq, -d/--min, -u/--max et\n"
|
||||
"L'un de ces paramètres est obligatoire : -f/--freq, -d/--min, -u/--max et\n"
|
||||
"-g/--governor\n"
|
||||
|
||||
#: utils/cpufreq-set.c:347
|
||||
@ -810,7 +810,7 @@ msgstr ""
|
||||
#: utils/cpuidle-info.c:48
|
||||
#, fuzzy, c-format
|
||||
msgid "Available idle states:"
|
||||
msgstr " plage de fréquence : "
|
||||
msgstr " plage de fréquence : "
|
||||
|
||||
#: utils/cpuidle-info.c:71
|
||||
#, c-format
|
||||
@ -911,7 +911,7 @@ msgstr "Usage : cpufreq-info [options]\n"
|
||||
#: utils/cpuidle-info.c:149
|
||||
#, fuzzy, c-format
|
||||
msgid " -s, --silent Only show general C-state information\n"
|
||||
msgstr " -e, --debug Afficher les informations de déboguage\n"
|
||||
msgstr " -e, --debug Afficher les informations de déboguage\n"
|
||||
|
||||
#: utils/cpuidle-info.c:150
|
||||
#, fuzzy, c-format
|
||||
@ -921,7 +921,7 @@ msgid ""
|
||||
" interface in older kernels\n"
|
||||
msgstr ""
|
||||
" -o, --proc Affiche les informations en utilisant l'interface\n"
|
||||
" fournie par /proc/cpufreq, présente dans les "
|
||||
" fournie par /proc/cpufreq, présente dans les "
|
||||
"versions\n"
|
||||
" 2.4 et les anciennes versions 2.6 du noyau\n"
|
||||
|
||||
@ -929,19 +929,19 @@ msgstr ""
|
||||
#, fuzzy, c-format
|
||||
msgid "You can't specify more than one output-specific argument\n"
|
||||
msgstr ""
|
||||
"On ne peut indiquer plus d'un paramètre --cpu, tout comme l'on ne peut\n"
|
||||
"spécifier plus d'un argument de formatage\n"
|
||||
"On ne peut indiquer plus d'un paramètre --cpu, tout comme l'on ne peut\n"
|
||||
"spécifier plus d'un argument de formatage\n"
|
||||
|
||||
#~ msgid ""
|
||||
#~ " -c CPU, --cpu CPU CPU number which information shall be determined "
|
||||
#~ "about\n"
|
||||
#~ msgstr ""
|
||||
#~ " -c CPU, --cpu CPU Numéro du CPU pour lequel l'information sera "
|
||||
#~ "affichée\n"
|
||||
#~ " -c CPU, --cpu CPU Numéro du CPU pour lequel l'information sera "
|
||||
#~ "affichée\n"
|
||||
|
||||
#~ msgid ""
|
||||
#~ " -c CPU, --cpu CPU number of CPU where cpufreq settings shall be "
|
||||
#~ "modified\n"
|
||||
#~ msgstr ""
|
||||
#~ " -c CPU, --cpu CPU numéro du CPU à prendre en compte pour les\n"
|
||||
#~ " -c CPU, --cpu CPU numéro du CPU à prendre en compte pour les\n"
|
||||
#~ " changements\n"
|
||||
|
||||
Loading…
Reference in New Issue
Block a user