mirror of
https://github.com/torvalds/linux.git
synced 2026-05-28 00:53:34 +02:00
Merge branch 'vfs.file' of gitolite.kernel.org:pub/scm/linux/kernel/git/vfs/vfs into slab/for-6.12/kmem_cache_args
Merge prerequisities from the vfs git tree for the following series that introduces kmem_cache_args. The vfs.file branch includes the addition of kmem_cache_create_rcu() which was needed in vfs for the filp cache optimization. The following series refactors this code.
This commit is contained in:
Vlastimil Babka
commit
e16f4f7098
|
|
@ -3451,6 +3451,12 @@ static int tun_chr_fasync(int fd, struct file *file, int on)
|
|||
struct tun_file *tfile = file->private_data;
|
||||
int ret;
|
||||
|
||||
if (on) {
|
||||
ret = file_f_owner_allocate(file);
|
||||
if (ret)
|
||||
goto out;
|
||||
}
|
||||
|
||||
if ((ret = fasync_helper(fd, file, on, &tfile->fasync)) < 0)
|
||||
goto out;
|
||||
|
||||
|
|
|
|||
|
|
@ -2225,6 +2225,12 @@ static int __tty_fasync(int fd, struct file *filp, int on)
|
|||
if (tty_paranoia_check(tty, file_inode(filp), "tty_fasync"))
|
||||
goto out;
|
||||
|
||||
if (on) {
|
||||
retval = file_f_owner_allocate(filp);
|
||||
if (retval)
|
||||
goto out;
|
||||
}
|
||||
|
||||
retval = fasync_helper(fd, filp, on, &tty->fasync);
|
||||
if (retval <= 0)
|
||||
goto out;
|
||||
|
|
|
|||
166
fs/fcntl.c
166
fs/fcntl.c
|
|
@ -33,6 +33,8 @@
|
|||
#include <asm/siginfo.h>
|
||||
#include <linux/uaccess.h>
|
||||
|
||||
#include "internal.h"
|
||||
|
||||
#define SETFL_MASK (O_APPEND | O_NONBLOCK | O_NDELAY | O_DIRECT | O_NOATIME)
|
||||
|
||||
static int setfl(int fd, struct file * filp, unsigned int arg)
|
||||
|
|
@ -87,22 +89,64 @@ static int setfl(int fd, struct file * filp, unsigned int arg)
|
|||
return error;
|
||||
}
|
||||
|
||||
/*
|
||||
* Allocate an file->f_owner struct if it doesn't exist, handling racing
|
||||
* allocations correctly.
|
||||
*/
|
||||
int file_f_owner_allocate(struct file *file)
|
||||
{
|
||||
struct fown_struct *f_owner;
|
||||
|
||||
f_owner = file_f_owner(file);
|
||||
if (f_owner)
|
||||
return 0;
|
||||
|
||||
f_owner = kzalloc(sizeof(struct fown_struct), GFP_KERNEL);
|
||||
if (!f_owner)
|
||||
return -ENOMEM;
|
||||
|
||||
rwlock_init(&f_owner->lock);
|
||||
f_owner->file = file;
|
||||
/* If someone else raced us, drop our allocation. */
|
||||
if (unlikely(cmpxchg(&file->f_owner, NULL, f_owner)))
|
||||
kfree(f_owner);
|
||||
return 0;
|
||||
}
|
||||
EXPORT_SYMBOL(file_f_owner_allocate);
|
||||
|
||||
void file_f_owner_release(struct file *file)
|
||||
{
|
||||
struct fown_struct *f_owner;
|
||||
|
||||
f_owner = file_f_owner(file);
|
||||
if (f_owner) {
|
||||
put_pid(f_owner->pid);
|
||||
kfree(f_owner);
|
||||
}
|
||||
}
|
||||
|
||||
static void f_modown(struct file *filp, struct pid *pid, enum pid_type type,
|
||||
int force)
|
||||
{
|
||||
write_lock_irq(&filp->f_owner.lock);
|
||||
if (force || !filp->f_owner.pid) {
|
||||
put_pid(filp->f_owner.pid);
|
||||
filp->f_owner.pid = get_pid(pid);
|
||||
filp->f_owner.pid_type = type;
|
||||
struct fown_struct *f_owner;
|
||||
|
||||
f_owner = file_f_owner(filp);
|
||||
if (WARN_ON_ONCE(!f_owner))
|
||||
return;
|
||||
|
||||
write_lock_irq(&f_owner->lock);
|
||||
if (force || !f_owner->pid) {
|
||||
put_pid(f_owner->pid);
|
||||
f_owner->pid = get_pid(pid);
|
||||
f_owner->pid_type = type;
|
||||
|
||||
if (pid) {
|
||||
const struct cred *cred = current_cred();
|
||||
filp->f_owner.uid = cred->uid;
|
||||
filp->f_owner.euid = cred->euid;
|
||||
f_owner->uid = cred->uid;
|
||||
f_owner->euid = cred->euid;
|
||||
}
|
||||
}
|
||||
write_unlock_irq(&filp->f_owner.lock);
|
||||
write_unlock_irq(&f_owner->lock);
|
||||
}
|
||||
|
||||
void __f_setown(struct file *filp, struct pid *pid, enum pid_type type,
|
||||
|
|
@ -119,6 +163,8 @@ int f_setown(struct file *filp, int who, int force)
|
|||
struct pid *pid = NULL;
|
||||
int ret = 0;
|
||||
|
||||
might_sleep();
|
||||
|
||||
type = PIDTYPE_TGID;
|
||||
if (who < 0) {
|
||||
/* avoid overflow below */
|
||||
|
|
@ -129,6 +175,10 @@ int f_setown(struct file *filp, int who, int force)
|
|||
who = -who;
|
||||
}
|
||||
|
||||
ret = file_f_owner_allocate(filp);
|
||||
if (ret)
|
||||
return ret;
|
||||
|
||||
rcu_read_lock();
|
||||
if (who) {
|
||||
pid = find_vpid(who);
|
||||
|
|
@ -152,16 +202,21 @@ void f_delown(struct file *filp)
|
|||
pid_t f_getown(struct file *filp)
|
||||
{
|
||||
pid_t pid = 0;
|
||||
struct fown_struct *f_owner;
|
||||
|
||||
read_lock_irq(&filp->f_owner.lock);
|
||||
f_owner = file_f_owner(filp);
|
||||
if (!f_owner)
|
||||
return pid;
|
||||
|
||||
read_lock_irq(&f_owner->lock);
|
||||
rcu_read_lock();
|
||||
if (pid_task(filp->f_owner.pid, filp->f_owner.pid_type)) {
|
||||
pid = pid_vnr(filp->f_owner.pid);
|
||||
if (filp->f_owner.pid_type == PIDTYPE_PGID)
|
||||
if (pid_task(f_owner->pid, f_owner->pid_type)) {
|
||||
pid = pid_vnr(f_owner->pid);
|
||||
if (f_owner->pid_type == PIDTYPE_PGID)
|
||||
pid = -pid;
|
||||
}
|
||||
rcu_read_unlock();
|
||||
read_unlock_irq(&filp->f_owner.lock);
|
||||
read_unlock_irq(&f_owner->lock);
|
||||
return pid;
|
||||
}
|
||||
|
||||
|
|
@ -194,6 +249,10 @@ static int f_setown_ex(struct file *filp, unsigned long arg)
|
|||
return -EINVAL;
|
||||
}
|
||||
|
||||
ret = file_f_owner_allocate(filp);
|
||||
if (ret)
|
||||
return ret;
|
||||
|
||||
rcu_read_lock();
|
||||
pid = find_vpid(owner.pid);
|
||||
if (owner.pid && !pid)
|
||||
|
|
@ -210,13 +269,20 @@ static int f_getown_ex(struct file *filp, unsigned long arg)
|
|||
struct f_owner_ex __user *owner_p = (void __user *)arg;
|
||||
struct f_owner_ex owner = {};
|
||||
int ret = 0;
|
||||
struct fown_struct *f_owner;
|
||||
enum pid_type pid_type = PIDTYPE_PID;
|
||||
|
||||
read_lock_irq(&filp->f_owner.lock);
|
||||
rcu_read_lock();
|
||||
if (pid_task(filp->f_owner.pid, filp->f_owner.pid_type))
|
||||
owner.pid = pid_vnr(filp->f_owner.pid);
|
||||
rcu_read_unlock();
|
||||
switch (filp->f_owner.pid_type) {
|
||||
f_owner = file_f_owner(filp);
|
||||
if (f_owner) {
|
||||
read_lock_irq(&f_owner->lock);
|
||||
rcu_read_lock();
|
||||
if (pid_task(f_owner->pid, f_owner->pid_type))
|
||||
owner.pid = pid_vnr(f_owner->pid);
|
||||
rcu_read_unlock();
|
||||
pid_type = f_owner->pid_type;
|
||||
}
|
||||
|
||||
switch (pid_type) {
|
||||
case PIDTYPE_PID:
|
||||
owner.type = F_OWNER_TID;
|
||||
break;
|
||||
|
|
@ -234,7 +300,8 @@ static int f_getown_ex(struct file *filp, unsigned long arg)
|
|||
ret = -EINVAL;
|
||||
break;
|
||||
}
|
||||
read_unlock_irq(&filp->f_owner.lock);
|
||||
if (f_owner)
|
||||
read_unlock_irq(&f_owner->lock);
|
||||
|
||||
if (!ret) {
|
||||
ret = copy_to_user(owner_p, &owner, sizeof(owner));
|
||||
|
|
@ -248,14 +315,18 @@ static int f_getown_ex(struct file *filp, unsigned long arg)
|
|||
static int f_getowner_uids(struct file *filp, unsigned long arg)
|
||||
{
|
||||
struct user_namespace *user_ns = current_user_ns();
|
||||
struct fown_struct *f_owner;
|
||||
uid_t __user *dst = (void __user *)arg;
|
||||
uid_t src[2];
|
||||
uid_t src[2] = {0, 0};
|
||||
int err;
|
||||
|
||||
read_lock_irq(&filp->f_owner.lock);
|
||||
src[0] = from_kuid(user_ns, filp->f_owner.uid);
|
||||
src[1] = from_kuid(user_ns, filp->f_owner.euid);
|
||||
read_unlock_irq(&filp->f_owner.lock);
|
||||
f_owner = file_f_owner(filp);
|
||||
if (f_owner) {
|
||||
read_lock_irq(&f_owner->lock);
|
||||
src[0] = from_kuid(user_ns, f_owner->uid);
|
||||
src[1] = from_kuid(user_ns, f_owner->euid);
|
||||
read_unlock_irq(&f_owner->lock);
|
||||
}
|
||||
|
||||
err = put_user(src[0], &dst[0]);
|
||||
err |= put_user(src[1], &dst[1]);
|
||||
|
|
@ -343,6 +414,30 @@ static long f_dupfd_query(int fd, struct file *filp)
|
|||
return f.file == filp;
|
||||
}
|
||||
|
||||
static int f_owner_sig(struct file *filp, int signum, bool setsig)
|
||||
{
|
||||
int ret = 0;
|
||||
struct fown_struct *f_owner;
|
||||
|
||||
might_sleep();
|
||||
|
||||
if (setsig) {
|
||||
if (!valid_signal(signum))
|
||||
return -EINVAL;
|
||||
|
||||
ret = file_f_owner_allocate(filp);
|
||||
if (ret)
|
||||
return ret;
|
||||
}
|
||||
|
||||
f_owner = file_f_owner(filp);
|
||||
if (setsig)
|
||||
f_owner->signum = signum;
|
||||
else if (f_owner)
|
||||
ret = f_owner->signum;
|
||||
return ret;
|
||||
}
|
||||
|
||||
static long do_fcntl(int fd, unsigned int cmd, unsigned long arg,
|
||||
struct file *filp)
|
||||
{
|
||||
|
|
@ -421,15 +516,10 @@ static long do_fcntl(int fd, unsigned int cmd, unsigned long arg,
|
|||
err = f_getowner_uids(filp, arg);
|
||||
break;
|
||||
case F_GETSIG:
|
||||
err = filp->f_owner.signum;
|
||||
err = f_owner_sig(filp, 0, false);
|
||||
break;
|
||||
case F_SETSIG:
|
||||
/* arg == 0 restores default behaviour. */
|
||||
if (!valid_signal(argi)) {
|
||||
break;
|
||||
}
|
||||
err = 0;
|
||||
filp->f_owner.signum = argi;
|
||||
err = f_owner_sig(filp, argi, true);
|
||||
break;
|
||||
case F_GETLEASE:
|
||||
err = fcntl_getlease(filp);
|
||||
|
|
@ -844,14 +934,19 @@ static void send_sigurg_to_task(struct task_struct *p,
|
|||
do_send_sig_info(SIGURG, SEND_SIG_PRIV, p, type);
|
||||
}
|
||||
|
||||
int send_sigurg(struct fown_struct *fown)
|
||||
int send_sigurg(struct file *file)
|
||||
{
|
||||
struct fown_struct *fown;
|
||||
struct task_struct *p;
|
||||
enum pid_type type;
|
||||
struct pid *pid;
|
||||
unsigned long flags;
|
||||
int ret = 0;
|
||||
|
||||
fown = file_f_owner(file);
|
||||
if (!fown)
|
||||
return 0;
|
||||
|
||||
read_lock_irqsave(&fown->lock, flags);
|
||||
|
||||
type = fown->pid_type;
|
||||
|
|
@ -1027,13 +1122,16 @@ static void kill_fasync_rcu(struct fasync_struct *fa, int sig, int band)
|
|||
}
|
||||
read_lock_irqsave(&fa->fa_lock, flags);
|
||||
if (fa->fa_file) {
|
||||
fown = &fa->fa_file->f_owner;
|
||||
fown = file_f_owner(fa->fa_file);
|
||||
if (!fown)
|
||||
goto next;
|
||||
/* Don't send SIGURG to processes which have not set a
|
||||
queued signum: SIGURG has its own default signalling
|
||||
mechanism. */
|
||||
if (!(sig == SIGURG && fown->signum == 0))
|
||||
send_sigio(fown, fa->fa_fd, band);
|
||||
}
|
||||
next:
|
||||
read_unlock_irqrestore(&fa->fa_lock, flags);
|
||||
fa = rcu_dereference(fa->fa_next);
|
||||
}
|
||||
|
|
|
|||
|
|
@ -155,7 +155,6 @@ static int init_file(struct file *f, int flags, const struct cred *cred)
|
|||
return error;
|
||||
}
|
||||
|
||||
rwlock_init(&f->f_owner.lock);
|
||||
spin_lock_init(&f->f_lock);
|
||||
mutex_init(&f->f_pos_lock);
|
||||
f->f_flags = flags;
|
||||
|
|
@ -425,7 +424,7 @@ static void __fput(struct file *file)
|
|||
cdev_put(inode->i_cdev);
|
||||
}
|
||||
fops_put(file->f_op);
|
||||
put_pid(file->f_owner.pid);
|
||||
file_f_owner_release(file);
|
||||
put_file_access(file);
|
||||
dput(dentry);
|
||||
if (unlikely(mode & FMODE_NEED_UNMOUNT))
|
||||
|
|
@ -512,9 +511,9 @@ EXPORT_SYMBOL(__fput_sync);
|
|||
|
||||
void __init files_init(void)
|
||||
{
|
||||
filp_cachep = kmem_cache_create("filp", sizeof(struct file), 0,
|
||||
SLAB_TYPESAFE_BY_RCU | SLAB_HWCACHE_ALIGN |
|
||||
SLAB_PANIC | SLAB_ACCOUNT, NULL);
|
||||
filp_cachep = kmem_cache_create_rcu("filp", sizeof(struct file),
|
||||
offsetof(struct file, f_freeptr),
|
||||
SLAB_HWCACHE_ALIGN | SLAB_PANIC | SLAB_ACCOUNT);
|
||||
percpu_counter_init(&nr_files, 0, GFP_KERNEL);
|
||||
}
|
||||
|
||||
|
|
|
|||
|
|
@ -337,3 +337,4 @@ static inline bool path_mounted(const struct path *path)
|
|||
{
|
||||
return path->mnt->mnt_root == path->dentry;
|
||||
}
|
||||
void file_f_owner_release(struct file *file);
|
||||
|
|
|
|||
|
|
@ -1451,7 +1451,7 @@ int lease_modify(struct file_lease *fl, int arg, struct list_head *dispose)
|
|||
struct file *filp = fl->c.flc_file;
|
||||
|
||||
f_delown(filp);
|
||||
filp->f_owner.signum = 0;
|
||||
file_f_owner(filp)->signum = 0;
|
||||
fasync_helper(0, fl->c.flc_file, 0, &fl->fl_fasync);
|
||||
if (fl->fl_fasync != NULL) {
|
||||
printk(KERN_ERR "locks_delete_lock: fasync == %p\n", fl->fl_fasync);
|
||||
|
|
@ -1783,6 +1783,10 @@ generic_add_lease(struct file *filp, int arg, struct file_lease **flp, void **pr
|
|||
lease = *flp;
|
||||
trace_generic_add_lease(inode, lease);
|
||||
|
||||
error = file_f_owner_allocate(filp);
|
||||
if (error)
|
||||
return error;
|
||||
|
||||
/* Note that arg is never F_UNLCK here */
|
||||
ctx = locks_get_lock_context(inode, arg);
|
||||
if (!ctx)
|
||||
|
|
|
|||
|
|
@ -110,7 +110,7 @@ static int dnotify_handle_event(struct fsnotify_mark *inode_mark, u32 mask,
|
|||
prev = &dn->dn_next;
|
||||
continue;
|
||||
}
|
||||
fown = &dn->dn_filp->f_owner;
|
||||
fown = file_f_owner(dn->dn_filp);
|
||||
send_sigio(fown, dn->dn_fd, POLL_MSG);
|
||||
if (dn->dn_mask & FS_DN_MULTISHOT)
|
||||
prev = &dn->dn_next;
|
||||
|
|
@ -316,6 +316,10 @@ int fcntl_dirnotify(int fd, struct file *filp, unsigned int arg)
|
|||
goto out_err;
|
||||
}
|
||||
|
||||
error = file_f_owner_allocate(filp);
|
||||
if (error)
|
||||
goto out_err;
|
||||
|
||||
/* set up the new_fsn_mark and new_dn_mark */
|
||||
new_fsn_mark = &new_dn_mark->fsn_mark;
|
||||
fsnotify_init_mark(new_fsn_mark, dnotify_group);
|
||||
|
|
|
|||
|
|
@ -947,6 +947,7 @@ static inline unsigned imajor(const struct inode *inode)
|
|||
}
|
||||
|
||||
struct fown_struct {
|
||||
struct file *file; /* backpointer for security modules */
|
||||
rwlock_t lock; /* protects pid, uid, euid fields */
|
||||
struct pid *pid; /* pid or -pgrp where SIGIO should be sent */
|
||||
enum pid_type pid_type; /* Kind of process group SIGIO should be sent to */
|
||||
|
|
@ -986,52 +987,65 @@ static inline int ra_has_index(struct file_ra_state *ra, pgoff_t index)
|
|||
index < ra->start + ra->size);
|
||||
}
|
||||
|
||||
/*
|
||||
* f_{lock,count,pos_lock} members can be highly contended and share
|
||||
* the same cacheline. f_{lock,mode} are very frequently used together
|
||||
* and so share the same cacheline as well. The read-mostly
|
||||
* f_{path,inode,op} are kept on a separate cacheline.
|
||||
/**
|
||||
* struct file - Represents a file
|
||||
* @f_count: reference count
|
||||
* @f_lock: Protects f_ep, f_flags. Must not be taken from IRQ context.
|
||||
* @f_mode: FMODE_* flags often used in hotpaths
|
||||
* @f_op: file operations
|
||||
* @f_mapping: Contents of a cacheable, mappable object.
|
||||
* @private_data: filesystem or driver specific data
|
||||
* @f_inode: cached inode
|
||||
* @f_flags: file flags
|
||||
* @f_iocb_flags: iocb flags
|
||||
* @f_cred: stashed credentials of creator/opener
|
||||
* @f_path: path of the file
|
||||
* @f_pos_lock: lock protecting file position
|
||||
* @f_pos: file position
|
||||
* @f_version: file version
|
||||
* @f_security: LSM security context of this file
|
||||
* @f_owner: file owner
|
||||
* @f_wb_err: writeback error
|
||||
* @f_sb_err: per sb writeback errors
|
||||
* @f_ep: link of all epoll hooks for this file
|
||||
* @f_task_work: task work entry point
|
||||
* @f_llist: work queue entrypoint
|
||||
* @f_ra: file's readahead state
|
||||
* @f_freeptr: Pointer used by SLAB_TYPESAFE_BY_RCU file cache (don't touch.)
|
||||
*/
|
||||
struct file {
|
||||
union {
|
||||
/* fput() uses task work when closing and freeing file (default). */
|
||||
struct callback_head f_task_work;
|
||||
/* fput() must use workqueue (most kernel threads). */
|
||||
struct llist_node f_llist;
|
||||
unsigned int f_iocb_flags;
|
||||
};
|
||||
|
||||
/*
|
||||
* Protects f_ep, f_flags.
|
||||
* Must not be taken from IRQ context.
|
||||
*/
|
||||
spinlock_t f_lock;
|
||||
fmode_t f_mode;
|
||||
atomic_long_t f_count;
|
||||
struct mutex f_pos_lock;
|
||||
loff_t f_pos;
|
||||
unsigned int f_flags;
|
||||
struct fown_struct f_owner;
|
||||
const struct cred *f_cred;
|
||||
struct file_ra_state f_ra;
|
||||
struct path f_path;
|
||||
struct inode *f_inode; /* cached value */
|
||||
atomic_long_t f_count;
|
||||
spinlock_t f_lock;
|
||||
fmode_t f_mode;
|
||||
const struct file_operations *f_op;
|
||||
|
||||
u64 f_version;
|
||||
struct address_space *f_mapping;
|
||||
void *private_data;
|
||||
struct inode *f_inode;
|
||||
unsigned int f_flags;
|
||||
unsigned int f_iocb_flags;
|
||||
const struct cred *f_cred;
|
||||
/* --- cacheline 1 boundary (64 bytes) --- */
|
||||
struct path f_path;
|
||||
struct mutex f_pos_lock;
|
||||
loff_t f_pos;
|
||||
u64 f_version;
|
||||
/* --- cacheline 2 boundary (128 bytes) --- */
|
||||
#ifdef CONFIG_SECURITY
|
||||
void *f_security;
|
||||
void *f_security;
|
||||
#endif
|
||||
/* needed for tty driver, and maybe others */
|
||||
void *private_data;
|
||||
|
||||
struct fown_struct *f_owner;
|
||||
errseq_t f_wb_err;
|
||||
errseq_t f_sb_err;
|
||||
#ifdef CONFIG_EPOLL
|
||||
/* Used by fs/eventpoll.c to link all the hooks to this file */
|
||||
struct hlist_head *f_ep;
|
||||
#endif /* #ifdef CONFIG_EPOLL */
|
||||
struct address_space *f_mapping;
|
||||
errseq_t f_wb_err;
|
||||
errseq_t f_sb_err; /* for syncfs */
|
||||
struct hlist_head *f_ep;
|
||||
#endif
|
||||
union {
|
||||
struct callback_head f_task_work;
|
||||
struct llist_node f_llist;
|
||||
struct file_ra_state f_ra;
|
||||
freeptr_t f_freeptr;
|
||||
};
|
||||
/* --- cacheline 3 boundary (192 bytes) --- */
|
||||
} __randomize_layout
|
||||
__attribute__((aligned(4))); /* lest something weird decides that 2 is OK */
|
||||
|
||||
|
|
@ -1076,6 +1090,12 @@ struct file_lease;
|
|||
#define OFFT_OFFSET_MAX type_max(off_t)
|
||||
#endif
|
||||
|
||||
int file_f_owner_allocate(struct file *file);
|
||||
static inline struct fown_struct *file_f_owner(const struct file *file)
|
||||
{
|
||||
return READ_ONCE(file->f_owner);
|
||||
}
|
||||
|
||||
extern void send_sigio(struct fown_struct *fown, int fd, int band);
|
||||
|
||||
static inline struct inode *file_inode(const struct file *f)
|
||||
|
|
@ -1124,7 +1144,7 @@ extern void __f_setown(struct file *filp, struct pid *, enum pid_type, int force
|
|||
extern int f_setown(struct file *filp, int who, int force);
|
||||
extern void f_delown(struct file *filp);
|
||||
extern pid_t f_getown(struct file *filp);
|
||||
extern int send_sigurg(struct fown_struct *fown);
|
||||
extern int send_sigurg(struct file *file);
|
||||
|
||||
/*
|
||||
* sb->s_flags. Note that these mirror the equivalent MS_* flags where
|
||||
|
|
|
|||
|
|
@ -212,6 +212,12 @@ enum _slab_flag_bits {
|
|||
#define SLAB_NO_OBJ_EXT __SLAB_FLAG_UNUSED
|
||||
#endif
|
||||
|
||||
/*
|
||||
* freeptr_t represents a SLUB freelist pointer, which might be encoded
|
||||
* and not dereferenceable if CONFIG_SLAB_FREELIST_HARDENED is enabled.
|
||||
*/
|
||||
typedef struct { unsigned long v; } freeptr_t;
|
||||
|
||||
/*
|
||||
* ZERO_SIZE_PTR will be returned for zero sized kmalloc requests.
|
||||
*
|
||||
|
|
@ -242,6 +248,9 @@ struct kmem_cache *kmem_cache_create_usercopy(const char *name,
|
|||
slab_flags_t flags,
|
||||
unsigned int useroffset, unsigned int usersize,
|
||||
void (*ctor)(void *));
|
||||
struct kmem_cache *kmem_cache_create_rcu(const char *name, unsigned int size,
|
||||
unsigned int freeptr_offset,
|
||||
slab_flags_t flags);
|
||||
void kmem_cache_destroy(struct kmem_cache *s);
|
||||
int kmem_cache_shrink(struct kmem_cache *s);
|
||||
|
||||
|
|
|
|||
|
|
@ -261,6 +261,8 @@ struct kmem_cache {
|
|||
unsigned int object_size; /* Object size without metadata */
|
||||
struct reciprocal_value reciprocal_size;
|
||||
unsigned int offset; /* Free pointer offset */
|
||||
/* Specific free pointer requested (if not UINT_MAX) */
|
||||
unsigned int rcu_freeptr_offset;
|
||||
#ifdef CONFIG_SLUB_CPU_PARTIAL
|
||||
/* Number of per cpu partial objects to keep around */
|
||||
unsigned int cpu_partial;
|
||||
|
|
|
|||
138
mm/slab_common.c
138
mm/slab_common.c
|
|
@ -202,10 +202,10 @@ struct kmem_cache *find_mergeable(unsigned int size, unsigned int align,
|
|||
}
|
||||
|
||||
static struct kmem_cache *create_cache(const char *name,
|
||||
unsigned int object_size, unsigned int align,
|
||||
slab_flags_t flags, unsigned int useroffset,
|
||||
unsigned int usersize, void (*ctor)(void *),
|
||||
struct kmem_cache *root_cache)
|
||||
unsigned int object_size, unsigned int freeptr_offset,
|
||||
unsigned int align, slab_flags_t flags,
|
||||
unsigned int useroffset, unsigned int usersize,
|
||||
void (*ctor)(void *))
|
||||
{
|
||||
struct kmem_cache *s;
|
||||
int err;
|
||||
|
|
@ -213,6 +213,13 @@ static struct kmem_cache *create_cache(const char *name,
|
|||
if (WARN_ON(useroffset + usersize > object_size))
|
||||
useroffset = usersize = 0;
|
||||
|
||||
/* If a custom freelist pointer is requested make sure it's sane. */
|
||||
err = -EINVAL;
|
||||
if (freeptr_offset != UINT_MAX &&
|
||||
(freeptr_offset >= object_size || !(flags & SLAB_TYPESAFE_BY_RCU) ||
|
||||
!IS_ALIGNED(freeptr_offset, sizeof(freeptr_t))))
|
||||
goto out;
|
||||
|
||||
err = -ENOMEM;
|
||||
s = kmem_cache_zalloc(kmem_cache, GFP_KERNEL);
|
||||
if (!s)
|
||||
|
|
@ -220,13 +227,13 @@ static struct kmem_cache *create_cache(const char *name,
|
|||
|
||||
s->name = name;
|
||||
s->size = s->object_size = object_size;
|
||||
s->rcu_freeptr_offset = freeptr_offset;
|
||||
s->align = align;
|
||||
s->ctor = ctor;
|
||||
#ifdef CONFIG_HARDENED_USERCOPY
|
||||
s->useroffset = useroffset;
|
||||
s->usersize = usersize;
|
||||
#endif
|
||||
|
||||
err = __kmem_cache_create(s, flags);
|
||||
if (err)
|
||||
goto out_free_cache;
|
||||
|
|
@ -241,38 +248,10 @@ static struct kmem_cache *create_cache(const char *name,
|
|||
return ERR_PTR(err);
|
||||
}
|
||||
|
||||
/**
|
||||
* kmem_cache_create_usercopy - Create a cache with a region suitable
|
||||
* for copying to userspace
|
||||
* @name: A string which is used in /proc/slabinfo to identify this cache.
|
||||
* @size: The size of objects to be created in this cache.
|
||||
* @align: The required alignment for the objects.
|
||||
* @flags: SLAB flags
|
||||
* @useroffset: Usercopy region offset
|
||||
* @usersize: Usercopy region size
|
||||
* @ctor: A constructor for the objects.
|
||||
*
|
||||
* Cannot be called within a interrupt, but can be interrupted.
|
||||
* The @ctor is run when new pages are allocated by the cache.
|
||||
*
|
||||
* The flags are
|
||||
*
|
||||
* %SLAB_POISON - Poison the slab with a known test pattern (a5a5a5a5)
|
||||
* to catch references to uninitialised memory.
|
||||
*
|
||||
* %SLAB_RED_ZONE - Insert `Red` zones around the allocated memory to check
|
||||
* for buffer overruns.
|
||||
*
|
||||
* %SLAB_HWCACHE_ALIGN - Align the objects in this cache to a hardware
|
||||
* cacheline. This can be beneficial if you're counting cycles as closely
|
||||
* as davem.
|
||||
*
|
||||
* Return: a pointer to the cache on success, NULL on failure.
|
||||
*/
|
||||
struct kmem_cache *
|
||||
kmem_cache_create_usercopy(const char *name,
|
||||
unsigned int size, unsigned int align,
|
||||
slab_flags_t flags,
|
||||
static struct kmem_cache *
|
||||
do_kmem_cache_create_usercopy(const char *name,
|
||||
unsigned int size, unsigned int freeptr_offset,
|
||||
unsigned int align, slab_flags_t flags,
|
||||
unsigned int useroffset, unsigned int usersize,
|
||||
void (*ctor)(void *))
|
||||
{
|
||||
|
|
@ -332,9 +311,9 @@ kmem_cache_create_usercopy(const char *name,
|
|||
goto out_unlock;
|
||||
}
|
||||
|
||||
s = create_cache(cache_name, size,
|
||||
s = create_cache(cache_name, size, freeptr_offset,
|
||||
calculate_alignment(flags, align, size),
|
||||
flags, useroffset, usersize, ctor, NULL);
|
||||
flags, useroffset, usersize, ctor);
|
||||
if (IS_ERR(s)) {
|
||||
err = PTR_ERR(s);
|
||||
kfree_const(cache_name);
|
||||
|
|
@ -356,6 +335,44 @@ kmem_cache_create_usercopy(const char *name,
|
|||
}
|
||||
return s;
|
||||
}
|
||||
|
||||
/**
|
||||
* kmem_cache_create_usercopy - Create a cache with a region suitable
|
||||
* for copying to userspace
|
||||
* @name: A string which is used in /proc/slabinfo to identify this cache.
|
||||
* @size: The size of objects to be created in this cache.
|
||||
* @align: The required alignment for the objects.
|
||||
* @flags: SLAB flags
|
||||
* @useroffset: Usercopy region offset
|
||||
* @usersize: Usercopy region size
|
||||
* @ctor: A constructor for the objects.
|
||||
*
|
||||
* Cannot be called within a interrupt, but can be interrupted.
|
||||
* The @ctor is run when new pages are allocated by the cache.
|
||||
*
|
||||
* The flags are
|
||||
*
|
||||
* %SLAB_POISON - Poison the slab with a known test pattern (a5a5a5a5)
|
||||
* to catch references to uninitialised memory.
|
||||
*
|
||||
* %SLAB_RED_ZONE - Insert `Red` zones around the allocated memory to check
|
||||
* for buffer overruns.
|
||||
*
|
||||
* %SLAB_HWCACHE_ALIGN - Align the objects in this cache to a hardware
|
||||
* cacheline. This can be beneficial if you're counting cycles as closely
|
||||
* as davem.
|
||||
*
|
||||
* Return: a pointer to the cache on success, NULL on failure.
|
||||
*/
|
||||
struct kmem_cache *
|
||||
kmem_cache_create_usercopy(const char *name, unsigned int size,
|
||||
unsigned int align, slab_flags_t flags,
|
||||
unsigned int useroffset, unsigned int usersize,
|
||||
void (*ctor)(void *))
|
||||
{
|
||||
return do_kmem_cache_create_usercopy(name, size, UINT_MAX, align, flags,
|
||||
useroffset, usersize, ctor);
|
||||
}
|
||||
EXPORT_SYMBOL(kmem_cache_create_usercopy);
|
||||
|
||||
/**
|
||||
|
|
@ -387,11 +404,50 @@ struct kmem_cache *
|
|||
kmem_cache_create(const char *name, unsigned int size, unsigned int align,
|
||||
slab_flags_t flags, void (*ctor)(void *))
|
||||
{
|
||||
return kmem_cache_create_usercopy(name, size, align, flags, 0, 0,
|
||||
ctor);
|
||||
return do_kmem_cache_create_usercopy(name, size, UINT_MAX, align, flags,
|
||||
0, 0, ctor);
|
||||
}
|
||||
EXPORT_SYMBOL(kmem_cache_create);
|
||||
|
||||
/**
|
||||
* kmem_cache_create_rcu - Create a SLAB_TYPESAFE_BY_RCU cache.
|
||||
* @name: A string which is used in /proc/slabinfo to identify this cache.
|
||||
* @size: The size of objects to be created in this cache.
|
||||
* @freeptr_offset: The offset into the memory to the free pointer
|
||||
* @flags: SLAB flags
|
||||
*
|
||||
* Cannot be called within an interrupt, but can be interrupted.
|
||||
*
|
||||
* See kmem_cache_create() for an explanation of possible @flags.
|
||||
*
|
||||
* By default SLAB_TYPESAFE_BY_RCU caches place the free pointer outside
|
||||
* of the object. This might cause the object to grow in size. Callers
|
||||
* that have a reason to avoid this can specify a custom free pointer
|
||||
* offset in their struct where the free pointer will be placed.
|
||||
*
|
||||
* Note that placing the free pointer inside the object requires the
|
||||
* caller to ensure that no fields are invalidated that are required to
|
||||
* guard against object recycling (See SLAB_TYPESAFE_BY_RCU for
|
||||
* details.).
|
||||
*
|
||||
* Using zero as a value for @freeptr_offset is valid. To request no
|
||||
* offset UINT_MAX must be specified.
|
||||
*
|
||||
* Note that @ctor isn't supported with custom free pointers as a @ctor
|
||||
* requires an external free pointer.
|
||||
*
|
||||
* Return: a pointer to the cache on success, NULL on failure.
|
||||
*/
|
||||
struct kmem_cache *kmem_cache_create_rcu(const char *name, unsigned int size,
|
||||
unsigned int freeptr_offset,
|
||||
slab_flags_t flags)
|
||||
{
|
||||
return do_kmem_cache_create_usercopy(name, size, freeptr_offset, 0,
|
||||
flags | SLAB_TYPESAFE_BY_RCU, 0, 0,
|
||||
NULL);
|
||||
}
|
||||
EXPORT_SYMBOL(kmem_cache_create_rcu);
|
||||
|
||||
static struct kmem_cache *kmem_buckets_cache __ro_after_init;
|
||||
|
||||
/**
|
||||
|
|
|
|||
20
mm/slub.c
20
mm/slub.c
|
|
@ -465,12 +465,6 @@ static struct workqueue_struct *flushwq;
|
|||
* Core slab cache functions
|
||||
*******************************************************************/
|
||||
|
||||
/*
|
||||
* freeptr_t represents a SLUB freelist pointer, which might be encoded
|
||||
* and not dereferenceable if CONFIG_SLAB_FREELIST_HARDENED is enabled.
|
||||
*/
|
||||
typedef struct { unsigned long v; } freeptr_t;
|
||||
|
||||
/*
|
||||
* Returns freelist pointer (ptr). With hardening, this is obfuscated
|
||||
* with an XOR of the address where the pointer is held and a per-cache
|
||||
|
|
@ -3921,6 +3915,9 @@ static void *__slab_alloc_node(struct kmem_cache *s,
|
|||
/*
|
||||
* If the object has been wiped upon free, make sure it's fully initialized by
|
||||
* zeroing out freelist pointer.
|
||||
*
|
||||
* Note that we also wipe custom freelist pointers specified via
|
||||
* s->rcu_freeptr_offset.
|
||||
*/
|
||||
static __always_inline void maybe_wipe_obj_freeptr(struct kmem_cache *s,
|
||||
void *obj)
|
||||
|
|
@ -5144,6 +5141,12 @@ static void set_cpu_partial(struct kmem_cache *s)
|
|||
#endif
|
||||
}
|
||||
|
||||
/* Was a valid freeptr offset requested? */
|
||||
static inline bool has_freeptr_offset(const struct kmem_cache *s)
|
||||
{
|
||||
return s->rcu_freeptr_offset != UINT_MAX;
|
||||
}
|
||||
|
||||
/*
|
||||
* calculate_sizes() determines the order and the distribution of data within
|
||||
* a slab object.
|
||||
|
|
@ -5189,7 +5192,8 @@ static int calculate_sizes(struct kmem_cache *s)
|
|||
*/
|
||||
s->inuse = size;
|
||||
|
||||
if ((flags & (SLAB_TYPESAFE_BY_RCU | SLAB_POISON)) || s->ctor ||
|
||||
if (((flags & SLAB_TYPESAFE_BY_RCU) && !has_freeptr_offset(s)) ||
|
||||
(flags & SLAB_POISON) || s->ctor ||
|
||||
((flags & SLAB_RED_ZONE) &&
|
||||
(s->object_size < sizeof(void *) || slub_debug_orig_size(s)))) {
|
||||
/*
|
||||
|
|
@ -5210,6 +5214,8 @@ static int calculate_sizes(struct kmem_cache *s)
|
|||
*/
|
||||
s->offset = size;
|
||||
size += sizeof(void *);
|
||||
} else if ((flags & SLAB_TYPESAFE_BY_RCU) && has_freeptr_offset(s)) {
|
||||
s->offset = s->rcu_freeptr_offset;
|
||||
} else {
|
||||
/*
|
||||
* Store freelist pointer near middle of object to keep
|
||||
|
|
|
|||
|
|
@ -3429,7 +3429,7 @@ static void sock_def_destruct(struct sock *sk)
|
|||
void sk_send_sigurg(struct sock *sk)
|
||||
{
|
||||
if (sk->sk_socket && sk->sk_socket->file)
|
||||
if (send_sigurg(&sk->sk_socket->file->f_owner))
|
||||
if (send_sigurg(sk->sk_socket->file))
|
||||
sk_wake_async(sk, SOCK_WAKE_URG, POLL_PRI);
|
||||
}
|
||||
EXPORT_SYMBOL(sk_send_sigurg);
|
||||
|
|
|
|||
|
|
@ -3950,7 +3950,7 @@ static int selinux_file_send_sigiotask(struct task_struct *tsk,
|
|||
struct file_security_struct *fsec;
|
||||
|
||||
/* struct fown_struct is never outside the context of a struct file */
|
||||
file = container_of(fown, struct file, f_owner);
|
||||
file = fown->file;
|
||||
|
||||
fsec = selinux_file(file);
|
||||
|
||||
|
|
|
|||
|
|
@ -1950,7 +1950,7 @@ static int smack_file_send_sigiotask(struct task_struct *tsk,
|
|||
/*
|
||||
* struct fown_struct is never outside the context of a struct file
|
||||
*/
|
||||
file = container_of(fown, struct file, f_owner);
|
||||
file = fown->file;
|
||||
|
||||
/* we don't log here as rc can be overriden */
|
||||
blob = smack_file(file);
|
||||
|
|
|
|||
Loading…
Reference in New Issue
Block a user