1/* 2 * Linux Security plug 3 * 4 * Copyright (C) 2001 WireX Communications, Inc <chris@wirex.com> 5 * Copyright (C) 2001 Greg Kroah-Hartman <greg@kroah.com> 6 * Copyright (C) 2001 Networks Associates Technology, Inc <ssmalley@nai.com> 7 * Copyright (C) 2001 James Morris <jmorris@intercode.com.au> 8 * Copyright (C) 2001 Silicon Graphics, Inc. (Trust Technology Group) 9 * 10 * This program is free software; you can redistribute it and/or modify 11 * it under the terms of the GNU General Public License as published by 12 * the Free Software Foundation; either version 2 of the License, or 13 * (at your option) any later version. 14 * 15 * Due to this file being licensed under the GPL there is controversy over 16 * whether this permits you to write a module that #includes this file 17 * without placing your module under the GPL. Please consult a lawyer for 18 * advice before doing this. 19 * 20 */ 21 22#ifndef __LINUX_SECURITY_H 23#define __LINUX_SECURITY_H 24 25#include <linux/key.h> 26#include <linux/capability.h> 27#include <linux/slab.h> 28#include <linux/err.h> 29#include <linux/string.h> 30 31struct linux_binprm; 32struct cred; 33struct rlimit; 34struct siginfo; 35struct sem_array; 36struct sembuf; 37struct kern_ipc_perm; 38struct audit_context; 39struct super_block; 40struct inode; 41struct dentry; 42struct file; 43struct vfsmount; 44struct path; 45struct qstr; 46struct nameidata; 47struct iattr; 48struct fown_struct; 49struct file_operations; 50struct shmid_kernel; 51struct msg_msg; 52struct msg_queue; 53struct xattr; 54struct xfrm_sec_ctx; 55struct mm_struct; 56 57/* Maximum number of letters for an LSM name string */ 58#define SECURITY_NAME_MAX 10 59 60/* If capable should audit the security request */ 61#define SECURITY_CAP_NOAUDIT 0 62#define SECURITY_CAP_AUDIT 1 63 64/* LSM Agnostic defines for sb_set_mnt_opts */ 65#define SECURITY_LSM_NATIVE_LABELS 1 66 67struct ctl_table; 68struct audit_krule; 69struct user_namespace; 70struct timezone; 71 72/* 73 * These functions are in security/capability.c and are used 74 * as the default capabilities functions 75 */ 76extern int cap_capable(const struct cred *cred, struct user_namespace *ns, 77 int cap, int audit); 78extern int cap_settime(const struct timespec *ts, const struct timezone *tz); 79extern int cap_ptrace_access_check(struct task_struct *child, unsigned int mode); 80extern int cap_ptrace_traceme(struct task_struct *parent); 81extern int cap_capget(struct task_struct *target, kernel_cap_t *effective, kernel_cap_t *inheritable, kernel_cap_t *permitted); 82extern int cap_capset(struct cred *new, const struct cred *old, 83 const kernel_cap_t *effective, 84 const kernel_cap_t *inheritable, 85 const kernel_cap_t *permitted); 86extern int cap_bprm_set_creds(struct linux_binprm *bprm); 87extern int cap_bprm_secureexec(struct linux_binprm *bprm); 88extern int cap_inode_setxattr(struct dentry *dentry, const char *name, 89 const void *value, size_t size, int flags); 90extern int cap_inode_removexattr(struct dentry *dentry, const char *name); 91extern int cap_inode_need_killpriv(struct dentry *dentry); 92extern int cap_inode_killpriv(struct dentry *dentry); 93extern int cap_mmap_addr(unsigned long addr); 94extern int cap_mmap_file(struct file *file, unsigned long reqprot, 95 unsigned long prot, unsigned long flags); 96extern int cap_task_fix_setuid(struct cred *new, const struct cred *old, int flags); 97extern int cap_task_prctl(int option, unsigned long arg2, unsigned long arg3, 98 unsigned long arg4, unsigned long arg5); 99extern int cap_task_setscheduler(struct task_struct *p); 100extern int cap_task_setioprio(struct task_struct *p, int ioprio); 101extern int cap_task_setnice(struct task_struct *p, int nice); 102extern int cap_vm_enough_memory(struct mm_struct *mm, long pages); 103 104struct msghdr; 105struct sk_buff; 106struct sock; 107struct sockaddr; 108struct socket; 109struct flowi; 110struct dst_entry; 111struct xfrm_selector; 112struct xfrm_policy; 113struct xfrm_state; 114struct xfrm_user_sec_ctx; 115struct seq_file; 116 117extern int cap_netlink_send(struct sock *sk, struct sk_buff *skb); 118 119void reset_security_ops(void); 120 121#ifdef CONFIG_MMU 122extern unsigned long mmap_min_addr; 123extern unsigned long dac_mmap_min_addr; 124#else 125#define mmap_min_addr 0UL 126#define dac_mmap_min_addr 0UL 127#endif 128 129/* 130 * Values used in the task_security_ops calls 131 */ 132/* setuid or setgid, id0 == uid or gid */ 133#define LSM_SETID_ID 1 134 135/* setreuid or setregid, id0 == real, id1 == eff */ 136#define LSM_SETID_RE 2 137 138/* setresuid or setresgid, id0 == real, id1 == eff, uid2 == saved */ 139#define LSM_SETID_RES 4 140 141/* setfsuid or setfsgid, id0 == fsuid or fsgid */ 142#define LSM_SETID_FS 8 143 144/* forward declares to avoid warnings */ 145struct sched_param; 146struct request_sock; 147 148/* bprm->unsafe reasons */ 149#define LSM_UNSAFE_SHARE 1 150#define LSM_UNSAFE_PTRACE 2 151#define LSM_UNSAFE_PTRACE_CAP 4 152#define LSM_UNSAFE_NO_NEW_PRIVS 8 153 154#ifdef CONFIG_MMU 155extern int mmap_min_addr_handler(struct ctl_table *table, int write, 156 void __user *buffer, size_t *lenp, loff_t *ppos); 157#endif 158 159/* security_inode_init_security callback function to write xattrs */ 160typedef int (*initxattrs) (struct inode *inode, 161 const struct xattr *xattr_array, void *fs_data); 162 163#ifdef CONFIG_SECURITY 164 165struct security_mnt_opts { 166 char **mnt_opts; 167 int *mnt_opts_flags; 168 int num_mnt_opts; 169}; 170 171static inline void security_init_mnt_opts(struct security_mnt_opts *opts) 172{ 173 opts->mnt_opts = NULL; 174 opts->mnt_opts_flags = NULL; 175 opts->num_mnt_opts = 0; 176} 177 178static inline void security_free_mnt_opts(struct security_mnt_opts *opts) 179{ 180 int i; 181 if (opts->mnt_opts) 182 for (i = 0; i < opts->num_mnt_opts; i++) 183 kfree(opts->mnt_opts[i]); 184 kfree(opts->mnt_opts); 185 opts->mnt_opts = NULL; 186 kfree(opts->mnt_opts_flags); 187 opts->mnt_opts_flags = NULL; 188 opts->num_mnt_opts = 0; 189} 190 191/** 192 * struct security_operations - main security structure 193 * 194 * Security module identifier. 195 * 196 * @name: 197 * A string that acts as a unique identifier for the LSM with max number 198 * of characters = SECURITY_NAME_MAX. 199 * 200 * Security hooks for program execution operations. 201 * 202 * @bprm_set_creds: 203 * Save security information in the bprm->security field, typically based 204 * on information about the bprm->file, for later use by the apply_creds 205 * hook. This hook may also optionally check permissions (e.g. for 206 * transitions between security domains). 207 * This hook may be called multiple times during a single execve, e.g. for 208 * interpreters. The hook can tell whether it has already been called by 209 * checking to see if @bprm->security is non-NULL. If so, then the hook 210 * may decide either to retain the security information saved earlier or 211 * to replace it. 212 * @bprm contains the linux_binprm structure. 213 * Return 0 if the hook is successful and permission is granted. 214 * @bprm_check_security: 215 * This hook mediates the point when a search for a binary handler will 216 * begin. It allows a check the @bprm->security value which is set in the 217 * preceding set_creds call. The primary difference from set_creds is 218 * that the argv list and envp list are reliably available in @bprm. This 219 * hook may be called multiple times during a single execve; and in each 220 * pass set_creds is called first. 221 * @bprm contains the linux_binprm structure. 222 * Return 0 if the hook is successful and permission is granted. 223 * @bprm_committing_creds: 224 * Prepare to install the new security attributes of a process being 225 * transformed by an execve operation, based on the old credentials 226 * pointed to by @current->cred and the information set in @bprm->cred by 227 * the bprm_set_creds hook. @bprm points to the linux_binprm structure. 228 * This hook is a good place to perform state changes on the process such 229 * as closing open file descriptors to which access will no longer be 230 * granted when the attributes are changed. This is called immediately 231 * before commit_creds(). 232 * @bprm_committed_creds: 233 * Tidy up after the installation of the new security attributes of a 234 * process being transformed by an execve operation. The new credentials 235 * have, by this point, been set to @current->cred. @bprm points to the 236 * linux_binprm structure. This hook is a good place to perform state 237 * changes on the process such as clearing out non-inheritable signal 238 * state. This is called immediately after commit_creds(). 239 * @bprm_secureexec: 240 * Return a boolean value (0 or 1) indicating whether a "secure exec" 241 * is required. The flag is passed in the auxiliary table 242 * on the initial stack to the ELF interpreter to indicate whether libc 243 * should enable secure mode. 244 * @bprm contains the linux_binprm structure. 245 * 246 * Security hooks for filesystem operations. 247 * 248 * @sb_alloc_security: 249 * Allocate and attach a security structure to the sb->s_security field. 250 * The s_security field is initialized to NULL when the structure is 251 * allocated. 252 * @sb contains the super_block structure to be modified. 253 * Return 0 if operation was successful. 254 * @sb_free_security: 255 * Deallocate and clear the sb->s_security field. 256 * @sb contains the super_block structure to be modified. 257 * @sb_statfs: 258 * Check permission before obtaining filesystem statistics for the @mnt 259 * mountpoint. 260 * @dentry is a handle on the superblock for the filesystem. 261 * Return 0 if permission is granted. 262 * @sb_mount: 263 * Check permission before an object specified by @dev_name is mounted on 264 * the mount point named by @nd. For an ordinary mount, @dev_name 265 * identifies a device if the file system type requires a device. For a 266 * remount (@flags & MS_REMOUNT), @dev_name is irrelevant. For a 267 * loopback/bind mount (@flags & MS_BIND), @dev_name identifies the 268 * pathname of the object being mounted. 269 * @dev_name contains the name for object being mounted. 270 * @path contains the path for mount point object. 271 * @type contains the filesystem type. 272 * @flags contains the mount flags. 273 * @data contains the filesystem-specific data. 274 * Return 0 if permission is granted. 275 * @sb_copy_data: 276 * Allow mount option data to be copied prior to parsing by the filesystem, 277 * so that the security module can extract security-specific mount 278 * options cleanly (a filesystem may modify the data e.g. with strsep()). 279 * This also allows the original mount data to be stripped of security- 280 * specific options to avoid having to make filesystems aware of them. 281 * @type the type of filesystem being mounted. 282 * @orig the original mount data copied from userspace. 283 * @copy copied data which will be passed to the security module. 284 * Returns 0 if the copy was successful. 285 * @sb_remount: 286 * Extracts security system specific mount options and verifies no changes 287 * are being made to those options. 288 * @sb superblock being remounted 289 * @data contains the filesystem-specific data. 290 * Return 0 if permission is granted. 291 * @sb_umount: 292 * Check permission before the @mnt file system is unmounted. 293 * @mnt contains the mounted file system. 294 * @flags contains the unmount flags, e.g. MNT_FORCE. 295 * Return 0 if permission is granted. 296 * @sb_pivotroot: 297 * Check permission before pivoting the root filesystem. 298 * @old_path contains the path for the new location of the current root (put_old). 299 * @new_path contains the path for the new root (new_root). 300 * Return 0 if permission is granted. 301 * @sb_set_mnt_opts: 302 * Set the security relevant mount options used for a superblock 303 * @sb the superblock to set security mount options for 304 * @opts binary data structure containing all lsm mount data 305 * @sb_clone_mnt_opts: 306 * Copy all security options from a given superblock to another 307 * @oldsb old superblock which contain information to clone 308 * @newsb new superblock which needs filled in 309 * @sb_parse_opts_str: 310 * Parse a string of security data filling in the opts structure 311 * @options string containing all mount options known by the LSM 312 * @opts binary data structure usable by the LSM 313 * @dentry_init_security: 314 * Compute a context for a dentry as the inode is not yet available 315 * since NFSv4 has no label backed by an EA anyway. 316 * @dentry dentry to use in calculating the context. 317 * @mode mode used to determine resource type. 318 * @name name of the last path component used to create file 319 * @ctx pointer to place the pointer to the resulting context in. 320 * @ctxlen point to place the length of the resulting context. 321 * 322 * 323 * Security hooks for inode operations. 324 * 325 * @inode_alloc_security: 326 * Allocate and attach a security structure to @inode->i_security. The 327 * i_security field is initialized to NULL when the inode structure is 328 * allocated. 329 * @inode contains the inode structure. 330 * Return 0 if operation was successful. 331 * @inode_free_security: 332 * @inode contains the inode structure. 333 * Deallocate the inode security structure and set @inode->i_security to 334 * NULL. 335 * @inode_init_security: 336 * Obtain the security attribute name suffix and value to set on a newly 337 * created inode and set up the incore security field for the new inode. 338 * This hook is called by the fs code as part of the inode creation 339 * transaction and provides for atomic labeling of the inode, unlike 340 * the post_create/mkdir/... hooks called by the VFS. The hook function 341 * is expected to allocate the name and value via kmalloc, with the caller 342 * being responsible for calling kfree after using them. 343 * If the security module does not use security attributes or does 344 * not wish to put a security attribute on this particular inode, 345 * then it should return -EOPNOTSUPP to skip this processing. 346 * @inode contains the inode structure of the newly created inode. 347 * @dir contains the inode structure of the parent directory. 348 * @qstr contains the last path component of the new object 349 * @name will be set to the allocated name suffix (e.g. selinux). 350 * @value will be set to the allocated attribute value. 351 * @len will be set to the length of the value. 352 * Returns 0 if @name and @value have been successfully set, 353 * -EOPNOTSUPP if no security attribute is needed, or 354 * -ENOMEM on memory allocation failure. 355 * @inode_create: 356 * Check permission to create a regular file. 357 * @dir contains inode structure of the parent of the new file. 358 * @dentry contains the dentry structure for the file to be created. 359 * @mode contains the file mode of the file to be created. 360 * Return 0 if permission is granted. 361 * @inode_link: 362 * Check permission before creating a new hard link to a file. 363 * @old_dentry contains the dentry structure for an existing link to the file. 364 * @dir contains the inode structure of the parent directory of the new link. 365 * @new_dentry contains the dentry structure for the new link. 366 * Return 0 if permission is granted. 367 * @path_link: 368 * Check permission before creating a new hard link to a file. 369 * @old_dentry contains the dentry structure for an existing link 370 * to the file. 371 * @new_dir contains the path structure of the parent directory of 372 * the new link. 373 * @new_dentry contains the dentry structure for the new link. 374 * Return 0 if permission is granted. 375 * @inode_unlink: 376 * Check the permission to remove a hard link to a file. 377 * @dir contains the inode structure of parent directory of the file. 378 * @dentry contains the dentry structure for file to be unlinked. 379 * Return 0 if permission is granted. 380 * @path_unlink: 381 * Check the permission to remove a hard link to a file. 382 * @dir contains the path structure of parent directory of the file. 383 * @dentry contains the dentry structure for file to be unlinked. 384 * Return 0 if permission is granted. 385 * @inode_symlink: 386 * Check the permission to create a symbolic link to a file. 387 * @dir contains the inode structure of parent directory of the symbolic link. 388 * @dentry contains the dentry structure of the symbolic link. 389 * @old_name contains the pathname of file. 390 * Return 0 if permission is granted. 391 * @path_symlink: 392 * Check the permission to create a symbolic link to a file. 393 * @dir contains the path structure of parent directory of 394 * the symbolic link. 395 * @dentry contains the dentry structure of the symbolic link. 396 * @old_name contains the pathname of file. 397 * Return 0 if permission is granted. 398 * @inode_mkdir: 399 * Check permissions to create a new directory in the existing directory 400 * associated with inode structure @dir. 401 * @dir contains the inode structure of parent of the directory to be created. 402 * @dentry contains the dentry structure of new directory. 403 * @mode contains the mode of new directory. 404 * Return 0 if permission is granted. 405 * @path_mkdir: 406 * Check permissions to create a new directory in the existing directory 407 * associated with path structure @path. 408 * @dir contains the path structure of parent of the directory 409 * to be created. 410 * @dentry contains the dentry structure of new directory. 411 * @mode contains the mode of new directory. 412 * Return 0 if permission is granted. 413 * @inode_rmdir: 414 * Check the permission to remove a directory. 415 * @dir contains the inode structure of parent of the directory to be removed. 416 * @dentry contains the dentry structure of directory to be removed. 417 * Return 0 if permission is granted. 418 * @path_rmdir: 419 * Check the permission to remove a directory. 420 * @dir contains the path structure of parent of the directory to be 421 * removed. 422 * @dentry contains the dentry structure of directory to be removed. 423 * Return 0 if permission is granted. 424 * @inode_mknod: 425 * Check permissions when creating a special file (or a socket or a fifo 426 * file created via the mknod system call). Note that if mknod operation 427 * is being done for a regular file, then the create hook will be called 428 * and not this hook. 429 * @dir contains the inode structure of parent of the new file. 430 * @dentry contains the dentry structure of the new file. 431 * @mode contains the mode of the new file. 432 * @dev contains the device number. 433 * Return 0 if permission is granted. 434 * @path_mknod: 435 * Check permissions when creating a file. Note that this hook is called 436 * even if mknod operation is being done for a regular file. 437 * @dir contains the path structure of parent of the new file. 438 * @dentry contains the dentry structure of the new file. 439 * @mode contains the mode of the new file. 440 * @dev contains the undecoded device number. Use new_decode_dev() to get 441 * the decoded device number. 442 * Return 0 if permission is granted. 443 * @inode_rename: 444 * Check for permission to rename a file or directory. 445 * @old_dir contains the inode structure for parent of the old link. 446 * @old_dentry contains the dentry structure of the old link. 447 * @new_dir contains the inode structure for parent of the new link. 448 * @new_dentry contains the dentry structure of the new link. 449 * Return 0 if permission is granted. 450 * @path_rename: 451 * Check for permission to rename a file or directory. 452 * @old_dir contains the path structure for parent of the old link. 453 * @old_dentry contains the dentry structure of the old link. 454 * @new_dir contains the path structure for parent of the new link. 455 * @new_dentry contains the dentry structure of the new link. 456 * Return 0 if permission is granted. 457 * @path_chmod: 458 * Check for permission to change DAC's permission of a file or directory. 459 * @dentry contains the dentry structure. 460 * @mnt contains the vfsmnt structure. 461 * @mode contains DAC's mode. 462 * Return 0 if permission is granted. 463 * @path_chown: 464 * Check for permission to change owner/group of a file or directory. 465 * @path contains the path structure. 466 * @uid contains new owner's ID. 467 * @gid contains new group's ID. 468 * Return 0 if permission is granted. 469 * @path_chroot: 470 * Check for permission to change root directory. 471 * @path contains the path structure. 472 * Return 0 if permission is granted. 473 * @inode_readlink: 474 * Check the permission to read the symbolic link. 475 * @dentry contains the dentry structure for the file link. 476 * Return 0 if permission is granted. 477 * @inode_follow_link: 478 * Check permission to follow a symbolic link when looking up a pathname. 479 * @dentry contains the dentry structure for the link. 480 * @nd contains the nameidata structure for the parent directory. 481 * Return 0 if permission is granted. 482 * @inode_permission: 483 * Check permission before accessing an inode. This hook is called by the 484 * existing Linux permission function, so a security module can use it to 485 * provide additional checking for existing Linux permission checks. 486 * Notice that this hook is called when a file is opened (as well as many 487 * other operations), whereas the file_security_ops permission hook is 488 * called when the actual read/write operations are performed. 489 * @inode contains the inode structure to check. 490 * @mask contains the permission mask. 491 * Return 0 if permission is granted. 492 * @inode_setattr: 493 * Check permission before setting file attributes. Note that the kernel 494 * call to notify_change is performed from several locations, whenever 495 * file attributes change (such as when a file is truncated, chown/chmod 496 * operations, transferring disk quotas, etc). 497 * @dentry contains the dentry structure for the file. 498 * @attr is the iattr structure containing the new file attributes. 499 * Return 0 if permission is granted. 500 * @path_truncate: 501 * Check permission before truncating a file. 502 * @path contains the path structure for the file. 503 * Return 0 if permission is granted. 504 * @inode_getattr: 505 * Check permission before obtaining file attributes. 506 * @mnt is the vfsmount where the dentry was looked up 507 * @dentry contains the dentry structure for the file. 508 * Return 0 if permission is granted. 509 * @inode_setxattr: 510 * Check permission before setting the extended attributes 511 * @value identified by @name for @dentry. 512 * Return 0 if permission is granted. 513 * @inode_post_setxattr: 514 * Update inode security field after successful setxattr operation. 515 * @value identified by @name for @dentry. 516 * @inode_getxattr: 517 * Check permission before obtaining the extended attributes 518 * identified by @name for @dentry. 519 * Return 0 if permission is granted. 520 * @inode_listxattr: 521 * Check permission before obtaining the list of extended attribute 522 * names for @dentry. 523 * Return 0 if permission is granted. 524 * @inode_removexattr: 525 * Check permission before removing the extended attribute 526 * identified by @name for @dentry. 527 * Return 0 if permission is granted. 528 * @inode_getsecurity: 529 * Retrieve a copy of the extended attribute representation of the 530 * security label associated with @name for @inode via @buffer. Note that 531 * @name is the remainder of the attribute name after the security prefix 532 * has been removed. @alloc is used to specify of the call should return a 533 * value via the buffer or just the value length Return size of buffer on 534 * success. 535 * @inode_setsecurity: 536 * Set the security label associated with @name for @inode from the 537 * extended attribute value @value. @size indicates the size of the 538 * @value in bytes. @flags may be XATTR_CREATE, XATTR_REPLACE, or 0. 539 * Note that @name is the remainder of the attribute name after the 540 * security. prefix has been removed. 541 * Return 0 on success. 542 * @inode_listsecurity: 543 * Copy the extended attribute names for the security labels 544 * associated with @inode into @buffer. The maximum size of @buffer 545 * is specified by @buffer_size. @buffer may be NULL to request 546 * the size of the buffer required. 547 * Returns number of bytes used/required on success. 548 * @inode_need_killpriv: 549 * Called when an inode has been changed. 550 * @dentry is the dentry being changed. 551 * Return <0 on error to abort the inode change operation. 552 * Return 0 if inode_killpriv does not need to be called. 553 * Return >0 if inode_killpriv does need to be called. 554 * @inode_killpriv: 555 * The setuid bit is being removed. Remove similar security labels. 556 * Called with the dentry->d_inode->i_mutex held. 557 * @dentry is the dentry being changed. 558 * Return 0 on success. If error is returned, then the operation 559 * causing setuid bit removal is failed. 560 * @inode_getsecid: 561 * Get the secid associated with the node. 562 * @inode contains a pointer to the inode. 563 * @secid contains a pointer to the location where result will be saved. 564 * In case of failure, @secid will be set to zero. 565 * 566 * Security hooks for file operations 567 * 568 * @file_permission: 569 * Check file permissions before accessing an open file. This hook is 570 * called by various operations that read or write files. A security 571 * module can use this hook to perform additional checking on these 572 * operations, e.g. to revalidate permissions on use to support privilege 573 * bracketing or policy changes. Notice that this hook is used when the 574 * actual read/write operations are performed, whereas the 575 * inode_security_ops hook is called when a file is opened (as well as 576 * many other operations). 577 * Caveat: Although this hook can be used to revalidate permissions for 578 * various system call operations that read or write files, it does not 579 * address the revalidation of permissions for memory-mapped files. 580 * Security modules must handle this separately if they need such 581 * revalidation. 582 * @file contains the file structure being accessed. 583 * @mask contains the requested permissions. 584 * Return 0 if permission is granted. 585 * @file_alloc_security: 586 * Allocate and attach a security structure to the file->f_security field. 587 * The security field is initialized to NULL when the structure is first 588 * created. 589 * @file contains the file structure to secure. 590 * Return 0 if the hook is successful and permission is granted. 591 * @file_free_security: 592 * Deallocate and free any security structures stored in file->f_security. 593 * @file contains the file structure being modified. 594 * @file_ioctl: 595 * @file contains the file structure. 596 * @cmd contains the operation to perform. 597 * @arg contains the operational arguments. 598 * Check permission for an ioctl operation on @file. Note that @arg 599 * sometimes represents a user space pointer; in other cases, it may be a 600 * simple integer value. When @arg represents a user space pointer, it 601 * should never be used by the security module. 602 * Return 0 if permission is granted. 603 * @mmap_addr : 604 * Check permissions for a mmap operation at @addr. 605 * @addr contains virtual address that will be used for the operation. 606 * Return 0 if permission is granted. 607 * @mmap_file : 608 * Check permissions for a mmap operation. The @file may be NULL, e.g. 609 * if mapping anonymous memory. 610 * @file contains the file structure for file to map (may be NULL). 611 * @reqprot contains the protection requested by the application. 612 * @prot contains the protection that will be applied by the kernel. 613 * @flags contains the operational flags. 614 * Return 0 if permission is granted. 615 * @file_mprotect: 616 * Check permissions before changing memory access permissions. 617 * @vma contains the memory region to modify. 618 * @reqprot contains the protection requested by the application. 619 * @prot contains the protection that will be applied by the kernel. 620 * Return 0 if permission is granted. 621 * @file_lock: 622 * Check permission before performing file locking operations. 623 * Note: this hook mediates both flock and fcntl style locks. 624 * @file contains the file structure. 625 * @cmd contains the posix-translated lock operation to perform 626 * (e.g. F_RDLCK, F_WRLCK). 627 * Return 0 if permission is granted. 628 * @file_fcntl: 629 * Check permission before allowing the file operation specified by @cmd 630 * from being performed on the file @file. Note that @arg sometimes 631 * represents a user space pointer; in other cases, it may be a simple 632 * integer value. When @arg represents a user space pointer, it should 633 * never be used by the security module. 634 * @file contains the file structure. 635 * @cmd contains the operation to be performed. 636 * @arg contains the operational arguments. 637 * Return 0 if permission is granted. 638 * @file_set_fowner: 639 * Save owner security information (typically from current->security) in 640 * file->f_security for later use by the send_sigiotask hook. 641 * @file contains the file structure to update. 642 * Return 0 on success. 643 * @file_send_sigiotask: 644 * Check permission for the file owner @fown to send SIGIO or SIGURG to the 645 * process @tsk. Note that this hook is sometimes called from interrupt. 646 * Note that the fown_struct, @fown, is never outside the context of a 647 * struct file, so the file structure (and associated security information) 648 * can always be obtained: 649 * container_of(fown, struct file, f_owner) 650 * @tsk contains the structure of task receiving signal. 651 * @fown contains the file owner information. 652 * @sig is the signal that will be sent. When 0, kernel sends SIGIO. 653 * Return 0 if permission is granted. 654 * @file_receive: 655 * This hook allows security modules to control the ability of a process 656 * to receive an open file descriptor via socket IPC. 657 * @file contains the file structure being received. 658 * Return 0 if permission is granted. 659 * @file_open 660 * Save open-time permission checking state for later use upon 661 * file_permission, and recheck access if anything has changed 662 * since inode_permission. 663 * 664 * Security hooks for task operations. 665 * 666 * @task_create: 667 * Check permission before creating a child process. See the clone(2) 668 * manual page for definitions of the @clone_flags. 669 * @clone_flags contains the flags indicating what should be shared. 670 * Return 0 if permission is granted. 671 * @task_free: 672 * @task task being freed 673 * Handle release of task-related resources. (Note that this can be called 674 * from interrupt context.) 675 * @cred_alloc_blank: 676 * @cred points to the credentials. 677 * @gfp indicates the atomicity of any memory allocations. 678 * Only allocate sufficient memory and attach to @cred such that 679 * cred_transfer() will not get ENOMEM. 680 * @cred_free: 681 * @cred points to the credentials. 682 * Deallocate and clear the cred->security field in a set of credentials. 683 * @cred_prepare: 684 * @new points to the new credentials. 685 * @old points to the original credentials. 686 * @gfp indicates the atomicity of any memory allocations. 687 * Prepare a new set of credentials by copying the data from the old set. 688 * @cred_transfer: 689 * @new points to the new credentials. 690 * @old points to the original credentials. 691 * Transfer data from original creds to new creds 692 * @kernel_act_as: 693 * Set the credentials for a kernel service to act as (subjective context). 694 * @new points to the credentials to be modified. 695 * @secid specifies the security ID to be set 696 * The current task must be the one that nominated @secid. 697 * Return 0 if successful. 698 * @kernel_create_files_as: 699 * Set the file creation context in a set of credentials to be the same as 700 * the objective context of the specified inode. 701 * @new points to the credentials to be modified. 702 * @inode points to the inode to use as a reference. 703 * The current task must be the one that nominated @inode. 704 * Return 0 if successful. 705 * @kernel_fw_from_file: 706 * Load firmware from userspace (not called for built-in firmware). 707 * @file contains the file structure pointing to the file containing 708 * the firmware to load. This argument will be NULL if the firmware 709 * was loaded via the uevent-triggered blob-based interface exposed 710 * by CONFIG_FW_LOADER_USER_HELPER. 711 * @buf pointer to buffer containing firmware contents. 712 * @size length of the firmware contents. 713 * Return 0 if permission is granted. 714 * @kernel_module_request: 715 * Ability to trigger the kernel to automatically upcall to userspace for 716 * userspace to load a kernel module with the given name. 717 * @kmod_name name of the module requested by the kernel 718 * Return 0 if successful. 719 * @kernel_module_from_file: 720 * Load a kernel module from userspace. 721 * @file contains the file structure pointing to the file containing 722 * the kernel module to load. If the module is being loaded from a blob, 723 * this argument will be NULL. 724 * Return 0 if permission is granted. 725 * @task_fix_setuid: 726 * Update the module's state after setting one or more of the user 727 * identity attributes of the current process. The @flags parameter 728 * indicates which of the set*uid system calls invoked this hook. If 729 * @new is the set of credentials that will be installed. Modifications 730 * should be made to this rather than to @current->cred. 731 * @old is the set of credentials that are being replaces 732 * @flags contains one of the LSM_SETID_* values. 733 * Return 0 on success. 734 * @task_setpgid: 735 * Check permission before setting the process group identifier of the 736 * process @p to @pgid. 737 * @p contains the task_struct for process being modified. 738 * @pgid contains the new pgid. 739 * Return 0 if permission is granted. 740 * @task_getpgid: 741 * Check permission before getting the process group identifier of the 742 * process @p. 743 * @p contains the task_struct for the process. 744 * Return 0 if permission is granted. 745 * @task_getsid: 746 * Check permission before getting the session identifier of the process 747 * @p. 748 * @p contains the task_struct for the process. 749 * Return 0 if permission is granted. 750 * @task_getsecid: 751 * Retrieve the security identifier of the process @p. 752 * @p contains the task_struct for the process and place is into @secid. 753 * In case of failure, @secid will be set to zero. 754 * 755 * @task_setnice: 756 * Check permission before setting the nice value of @p to @nice. 757 * @p contains the task_struct of process. 758 * @nice contains the new nice value. 759 * Return 0 if permission is granted. 760 * @task_setioprio 761 * Check permission before setting the ioprio value of @p to @ioprio. 762 * @p contains the task_struct of process. 763 * @ioprio contains the new ioprio value 764 * Return 0 if permission is granted. 765 * @task_getioprio 766 * Check permission before getting the ioprio value of @p. 767 * @p contains the task_struct of process. 768 * Return 0 if permission is granted. 769 * @task_setrlimit: 770 * Check permission before setting the resource limits of the current 771 * process for @resource to @new_rlim. The old resource limit values can 772 * be examined by dereferencing (current->signal->rlim + resource). 773 * @resource contains the resource whose limit is being set. 774 * @new_rlim contains the new limits for @resource. 775 * Return 0 if permission is granted. 776 * @task_setscheduler: 777 * Check permission before setting scheduling policy and/or parameters of 778 * process @p based on @policy and @lp. 779 * @p contains the task_struct for process. 780 * @policy contains the scheduling policy. 781 * @lp contains the scheduling parameters. 782 * Return 0 if permission is granted. 783 * @task_getscheduler: 784 * Check permission before obtaining scheduling information for process 785 * @p. 786 * @p contains the task_struct for process. 787 * Return 0 if permission is granted. 788 * @task_movememory 789 * Check permission before moving memory owned by process @p. 790 * @p contains the task_struct for process. 791 * Return 0 if permission is granted. 792 * @task_kill: 793 * Check permission before sending signal @sig to @p. @info can be NULL, 794 * the constant 1, or a pointer to a siginfo structure. If @info is 1 or 795 * SI_FROMKERNEL(info) is true, then the signal should be viewed as coming 796 * from the kernel and should typically be permitted. 797 * SIGIO signals are handled separately by the send_sigiotask hook in 798 * file_security_ops. 799 * @p contains the task_struct for process. 800 * @info contains the signal information. 801 * @sig contains the signal value. 802 * @secid contains the sid of the process where the signal originated 803 * Return 0 if permission is granted. 804 * @task_wait: 805 * Check permission before allowing a process to reap a child process @p 806 * and collect its status information. 807 * @p contains the task_struct for process. 808 * Return 0 if permission is granted. 809 * @task_prctl: 810 * Check permission before performing a process control operation on the 811 * current process. 812 * @option contains the operation. 813 * @arg2 contains a argument. 814 * @arg3 contains a argument. 815 * @arg4 contains a argument. 816 * @arg5 contains a argument. 817 * Return -ENOSYS if no-one wanted to handle this op, any other value to 818 * cause prctl() to return immediately with that value. 819 * @task_to_inode: 820 * Set the security attributes for an inode based on an associated task's 821 * security attributes, e.g. for /proc/pid inodes. 822 * @p contains the task_struct for the task. 823 * @inode contains the inode structure for the inode. 824 * 825 * Security hooks for Netlink messaging. 826 * 827 * @netlink_send: 828 * Save security information for a netlink message so that permission 829 * checking can be performed when the message is processed. The security 830 * information can be saved using the eff_cap field of the 831 * netlink_skb_parms structure. Also may be used to provide fine 832 * grained control over message transmission. 833 * @sk associated sock of task sending the message. 834 * @skb contains the sk_buff structure for the netlink message. 835 * Return 0 if the information was successfully saved and message 836 * is allowed to be transmitted. 837 * 838 * Security hooks for Unix domain networking. 839 * 840 * @unix_stream_connect: 841 * Check permissions before establishing a Unix domain stream connection 842 * between @sock and @other. 843 * @sock contains the sock structure. 844 * @other contains the peer sock structure. 845 * @newsk contains the new sock structure. 846 * Return 0 if permission is granted. 847 * @unix_may_send: 848 * Check permissions before connecting or sending datagrams from @sock to 849 * @other. 850 * @sock contains the socket structure. 851 * @other contains the peer socket structure. 852 * Return 0 if permission is granted. 853 * 854 * The @unix_stream_connect and @unix_may_send hooks were necessary because 855 * Linux provides an alternative to the conventional file name space for Unix 856 * domain sockets. Whereas binding and connecting to sockets in the file name 857 * space is mediated by the typical file permissions (and caught by the mknod 858 * and permission hooks in inode_security_ops), binding and connecting to 859 * sockets in the abstract name space is completely unmediated. Sufficient 860 * control of Unix domain sockets in the abstract name space isn't possible 861 * using only the socket layer hooks, since we need to know the actual target 862 * socket, which is not looked up until we are inside the af_unix code. 863 * 864 * Security hooks for socket operations. 865 * 866 * @socket_create: 867 * Check permissions prior to creating a new socket. 868 * @family contains the requested protocol family. 869 * @type contains the requested communications type. 870 * @protocol contains the requested protocol. 871 * @kern set to 1 if a kernel socket. 872 * Return 0 if permission is granted. 873 * @socket_post_create: 874 * This hook allows a module to update or allocate a per-socket security 875 * structure. Note that the security field was not added directly to the 876 * socket structure, but rather, the socket security information is stored 877 * in the associated inode. Typically, the inode alloc_security hook will 878 * allocate and and attach security information to 879 * sock->inode->i_security. This hook may be used to update the 880 * sock->inode->i_security field with additional information that wasn't 881 * available when the inode was allocated. 882 * @sock contains the newly created socket structure. 883 * @family contains the requested protocol family. 884 * @type contains the requested communications type. 885 * @protocol contains the requested protocol. 886 * @kern set to 1 if a kernel socket. 887 * @socket_bind: 888 * Check permission before socket protocol layer bind operation is 889 * performed and the socket @sock is bound to the address specified in the 890 * @address parameter. 891 * @sock contains the socket structure. 892 * @address contains the address to bind to. 893 * @addrlen contains the length of address. 894 * Return 0 if permission is granted. 895 * @socket_connect: 896 * Check permission before socket protocol layer connect operation 897 * attempts to connect socket @sock to a remote address, @address. 898 * @sock contains the socket structure. 899 * @address contains the address of remote endpoint. 900 * @addrlen contains the length of address. 901 * Return 0 if permission is granted. 902 * @socket_listen: 903 * Check permission before socket protocol layer listen operation. 904 * @sock contains the socket structure. 905 * @backlog contains the maximum length for the pending connection queue. 906 * Return 0 if permission is granted. 907 * @socket_accept: 908 * Check permission before accepting a new connection. Note that the new 909 * socket, @newsock, has been created and some information copied to it, 910 * but the accept operation has not actually been performed. 911 * @sock contains the listening socket structure. 912 * @newsock contains the newly created server socket for connection. 913 * Return 0 if permission is granted. 914 * @socket_sendmsg: 915 * Check permission before transmitting a message to another socket. 916 * @sock contains the socket structure. 917 * @msg contains the message to be transmitted. 918 * @size contains the size of message. 919 * Return 0 if permission is granted. 920 * @socket_recvmsg: 921 * Check permission before receiving a message from a socket. 922 * @sock contains the socket structure. 923 * @msg contains the message structure. 924 * @size contains the size of message structure. 925 * @flags contains the operational flags. 926 * Return 0 if permission is granted. 927 * @socket_getsockname: 928 * Check permission before the local address (name) of the socket object 929 * @sock is retrieved. 930 * @sock contains the socket structure. 931 * Return 0 if permission is granted. 932 * @socket_getpeername: 933 * Check permission before the remote address (name) of a socket object 934 * @sock is retrieved. 935 * @sock contains the socket structure. 936 * Return 0 if permission is granted. 937 * @socket_getsockopt: 938 * Check permissions before retrieving the options associated with socket 939 * @sock. 940 * @sock contains the socket structure. 941 * @level contains the protocol level to retrieve option from. 942 * @optname contains the name of option to retrieve. 943 * Return 0 if permission is granted. 944 * @socket_setsockopt: 945 * Check permissions before setting the options associated with socket 946 * @sock. 947 * @sock contains the socket structure. 948 * @level contains the protocol level to set options for. 949 * @optname contains the name of the option to set. 950 * Return 0 if permission is granted. 951 * @socket_shutdown: 952 * Checks permission before all or part of a connection on the socket 953 * @sock is shut down. 954 * @sock contains the socket structure. 955 * @how contains the flag indicating how future sends and receives are handled. 956 * Return 0 if permission is granted. 957 * @socket_sock_rcv_skb: 958 * Check permissions on incoming network packets. This hook is distinct 959 * from Netfilter's IP input hooks since it is the first time that the 960 * incoming sk_buff @skb has been associated with a particular socket, @sk. 961 * Must not sleep inside this hook because some callers hold spinlocks. 962 * @sk contains the sock (not socket) associated with the incoming sk_buff. 963 * @skb contains the incoming network data. 964 * @socket_getpeersec_stream: 965 * This hook allows the security module to provide peer socket security 966 * state for unix or connected tcp sockets to userspace via getsockopt 967 * SO_GETPEERSEC. For tcp sockets this can be meaningful if the 968 * socket is associated with an ipsec SA. 969 * @sock is the local socket. 970 * @optval userspace memory where the security state is to be copied. 971 * @optlen userspace int where the module should copy the actual length 972 * of the security state. 973 * @len as input is the maximum length to copy to userspace provided 974 * by the caller. 975 * Return 0 if all is well, otherwise, typical getsockopt return 976 * values. 977 * @socket_getpeersec_dgram: 978 * This hook allows the security module to provide peer socket security 979 * state for udp sockets on a per-packet basis to userspace via 980 * getsockopt SO_GETPEERSEC. The application must first have indicated 981 * the IP_PASSSEC option via getsockopt. It can then retrieve the 982 * security state returned by this hook for a packet via the SCM_SECURITY 983 * ancillary message type. 984 * @skb is the skbuff for the packet being queried 985 * @secdata is a pointer to a buffer in which to copy the security data 986 * @seclen is the maximum length for @secdata 987 * Return 0 on success, error on failure. 988 * @sk_alloc_security: 989 * Allocate and attach a security structure to the sk->sk_security field, 990 * which is used to copy security attributes between local stream sockets. 991 * @sk_free_security: 992 * Deallocate security structure. 993 * @sk_clone_security: 994 * Clone/copy security structure. 995 * @sk_getsecid: 996 * Retrieve the LSM-specific secid for the sock to enable caching of network 997 * authorizations. 998 * @sock_graft: 999 * Sets the socket's isec sid to the sock's sid. 1000 * @inet_conn_request: 1001 * Sets the openreq's sid to socket's sid with MLS portion taken from peer sid. 1002 * @inet_csk_clone: 1003 * Sets the new child socket's sid to the openreq sid. 1004 * @inet_conn_established: 1005 * Sets the connection's peersid to the secmark on skb. 1006 * @secmark_relabel_packet: 1007 * check if the process should be allowed to relabel packets to the given secid 1008 * @security_secmark_refcount_inc 1009 * tells the LSM to increment the number of secmark labeling rules loaded 1010 * @security_secmark_refcount_dec 1011 * tells the LSM to decrement the number of secmark labeling rules loaded 1012 * @req_classify_flow: 1013 * Sets the flow's sid to the openreq sid. 1014 * @tun_dev_alloc_security: 1015 * This hook allows a module to allocate a security structure for a TUN 1016 * device. 1017 * @security pointer to a security structure pointer. 1018 * Returns a zero on success, negative values on failure. 1019 * @tun_dev_free_security: 1020 * This hook allows a module to free the security structure for a TUN 1021 * device. 1022 * @security pointer to the TUN device's security structure 1023 * @tun_dev_create: 1024 * Check permissions prior to creating a new TUN device. 1025 * @tun_dev_attach_queue: 1026 * Check permissions prior to attaching to a TUN device queue. 1027 * @security pointer to the TUN device's security structure. 1028 * @tun_dev_attach: 1029 * This hook can be used by the module to update any security state 1030 * associated with the TUN device's sock structure. 1031 * @sk contains the existing sock structure. 1032 * @security pointer to the TUN device's security structure. 1033 * @tun_dev_open: 1034 * This hook can be used by the module to update any security state 1035 * associated with the TUN device's security structure. 1036 * @security pointer to the TUN devices's security structure. 1037 * @skb_owned_by: 1038 * This hook sets the packet's owning sock. 1039 * @skb is the packet. 1040 * @sk the sock which owns the packet. 1041 * 1042 * Security hooks for XFRM operations. 1043 * 1044 * @xfrm_policy_alloc_security: 1045 * @ctxp is a pointer to the xfrm_sec_ctx being added to Security Policy 1046 * Database used by the XFRM system. 1047 * @sec_ctx contains the security context information being provided by 1048 * the user-level policy update program (e.g., setkey). 1049 * Allocate a security structure to the xp->security field; the security 1050 * field is initialized to NULL when the xfrm_policy is allocated. 1051 * Return 0 if operation was successful (memory to allocate, legal context) 1052 * @gfp is to specify the context for the allocation 1053 * @xfrm_policy_clone_security: 1054 * @old_ctx contains an existing xfrm_sec_ctx. 1055 * @new_ctxp contains a new xfrm_sec_ctx being cloned from old. 1056 * Allocate a security structure in new_ctxp that contains the 1057 * information from the old_ctx structure. 1058 * Return 0 if operation was successful (memory to allocate). 1059 * @xfrm_policy_free_security: 1060 * @ctx contains the xfrm_sec_ctx 1061 * Deallocate xp->security. 1062 * @xfrm_policy_delete_security: 1063 * @ctx contains the xfrm_sec_ctx. 1064 * Authorize deletion of xp->security. 1065 * @xfrm_state_alloc: 1066 * @x contains the xfrm_state being added to the Security Association 1067 * Database by the XFRM system. 1068 * @sec_ctx contains the security context information being provided by 1069 * the user-level SA generation program (e.g., setkey or racoon). 1070 * Allocate a security structure to the x->security field; the security 1071 * field is initialized to NULL when the xfrm_state is allocated. Set the 1072 * context to correspond to sec_ctx. Return 0 if operation was successful 1073 * (memory to allocate, legal context). 1074 * @xfrm_state_alloc_acquire: 1075 * @x contains the xfrm_state being added to the Security Association 1076 * Database by the XFRM system. 1077 * @polsec contains the policy's security context. 1078 * @secid contains the secid from which to take the mls portion of the 1079 * context. 1080 * Allocate a security structure to the x->security field; the security 1081 * field is initialized to NULL when the xfrm_state is allocated. Set the 1082 * context to correspond to secid. Return 0 if operation was successful 1083 * (memory to allocate, legal context). 1084 * @xfrm_state_free_security: 1085 * @x contains the xfrm_state. 1086 * Deallocate x->security. 1087 * @xfrm_state_delete_security: 1088 * @x contains the xfrm_state. 1089 * Authorize deletion of x->security. 1090 * @xfrm_policy_lookup: 1091 * @ctx contains the xfrm_sec_ctx for which the access control is being 1092 * checked. 1093 * @fl_secid contains the flow security label that is used to authorize 1094 * access to the policy xp. 1095 * @dir contains the direction of the flow (input or output). 1096 * Check permission when a flow selects a xfrm_policy for processing 1097 * XFRMs on a packet. The hook is called when selecting either a 1098 * per-socket policy or a generic xfrm policy. 1099 * Return 0 if permission is granted, -ESRCH otherwise, or -errno 1100 * on other errors. 1101 * @xfrm_state_pol_flow_match: 1102 * @x contains the state to match. 1103 * @xp contains the policy to check for a match. 1104 * @fl contains the flow to check for a match. 1105 * Return 1 if there is a match. 1106 * @xfrm_decode_session: 1107 * @skb points to skb to decode. 1108 * @secid points to the flow key secid to set. 1109 * @ckall says if all xfrms used should be checked for same secid. 1110 * Return 0 if ckall is zero or all xfrms used have the same secid. 1111 * 1112 * Security hooks affecting all Key Management operations 1113 * 1114 * @key_alloc: 1115 * Permit allocation of a key and assign security data. Note that key does 1116 * not have a serial number assigned at this point. 1117 * @key points to the key. 1118 * @flags is the allocation flags 1119 * Return 0 if permission is granted, -ve error otherwise. 1120 * @key_free: 1121 * Notification of destruction; free security data. 1122 * @key points to the key. 1123 * No return value. 1124 * @key_permission: 1125 * See whether a specific operational right is granted to a process on a 1126 * key. 1127 * @key_ref refers to the key (key pointer + possession attribute bit). 1128 * @cred points to the credentials to provide the context against which to 1129 * evaluate the security data on the key. 1130 * @perm describes the combination of permissions required of this key. 1131 * Return 0 if permission is granted, -ve error otherwise. 1132 * @key_getsecurity: 1133 * Get a textual representation of the security context attached to a key 1134 * for the purposes of honouring KEYCTL_GETSECURITY. This function 1135 * allocates the storage for the NUL-terminated string and the caller 1136 * should free it. 1137 * @key points to the key to be queried. 1138 * @_buffer points to a pointer that should be set to point to the 1139 * resulting string (if no label or an error occurs). 1140 * Return the length of the string (including terminating NUL) or -ve if 1141 * an error. 1142 * May also return 0 (and a NULL buffer pointer) if there is no label. 1143 * 1144 * Security hooks affecting all System V IPC operations. 1145 * 1146 * @ipc_permission: 1147 * Check permissions for access to IPC 1148 * @ipcp contains the kernel IPC permission structure 1149 * @flag contains the desired (requested) permission set 1150 * Return 0 if permission is granted. 1151 * @ipc_getsecid: 1152 * Get the secid associated with the ipc object. 1153 * @ipcp contains the kernel IPC permission structure. 1154 * @secid contains a pointer to the location where result will be saved. 1155 * In case of failure, @secid will be set to zero. 1156 * 1157 * Security hooks for individual messages held in System V IPC message queues 1158 * @msg_msg_alloc_security: 1159 * Allocate and attach a security structure to the msg->security field. 1160 * The security field is initialized to NULL when the structure is first 1161 * created. 1162 * @msg contains the message structure to be modified. 1163 * Return 0 if operation was successful and permission is granted. 1164 * @msg_msg_free_security: 1165 * Deallocate the security structure for this message. 1166 * @msg contains the message structure to be modified. 1167 * 1168 * Security hooks for System V IPC Message Queues 1169 * 1170 * @msg_queue_alloc_security: 1171 * Allocate and attach a security structure to the 1172 * msq->q_perm.security field. The security field is initialized to 1173 * NULL when the structure is first created. 1174 * @msq contains the message queue structure to be modified. 1175 * Return 0 if operation was successful and permission is granted. 1176 * @msg_queue_free_security: 1177 * Deallocate security structure for this message queue. 1178 * @msq contains the message queue structure to be modified. 1179 * @msg_queue_associate: 1180 * Check permission when a message queue is requested through the 1181 * msgget system call. This hook is only called when returning the 1182 * message queue identifier for an existing message queue, not when a 1183 * new message queue is created. 1184 * @msq contains the message queue to act upon. 1185 * @msqflg contains the operation control flags. 1186 * Return 0 if permission is granted. 1187 * @msg_queue_msgctl: 1188 * Check permission when a message control operation specified by @cmd 1189 * is to be performed on the message queue @msq. 1190 * The @msq may be NULL, e.g. for IPC_INFO or MSG_INFO. 1191 * @msq contains the message queue to act upon. May be NULL. 1192 * @cmd contains the operation to be performed. 1193 * Return 0 if permission is granted. 1194 * @msg_queue_msgsnd: 1195 * Check permission before a message, @msg, is enqueued on the message 1196 * queue, @msq. 1197 * @msq contains the message queue to send message to. 1198 * @msg contains the message to be enqueued. 1199 * @msqflg contains operational flags. 1200 * Return 0 if permission is granted. 1201 * @msg_queue_msgrcv: 1202 * Check permission before a message, @msg, is removed from the message 1203 * queue, @msq. The @target task structure contains a pointer to the 1204 * process that will be receiving the message (not equal to the current 1205 * process when inline receives are being performed). 1206 * @msq contains the message queue to retrieve message from. 1207 * @msg contains the message destination. 1208 * @target contains the task structure for recipient process. 1209 * @type contains the type of message requested. 1210 * @mode contains the operational flags. 1211 * Return 0 if permission is granted. 1212 * 1213 * Security hooks for System V Shared Memory Segments 1214 * 1215 * @shm_alloc_security: 1216 * Allocate and attach a security structure to the shp->shm_perm.security 1217 * field. The security field is initialized to NULL when the structure is 1218 * first created. 1219 * @shp contains the shared memory structure to be modified. 1220 * Return 0 if operation was successful and permission is granted. 1221 * @shm_free_security: 1222 * Deallocate the security struct for this memory segment. 1223 * @shp contains the shared memory structure to be modified. 1224 * @shm_associate: 1225 * Check permission when a shared memory region is requested through the 1226 * shmget system call. This hook is only called when returning the shared 1227 * memory region identifier for an existing region, not when a new shared 1228 * memory region is created. 1229 * @shp contains the shared memory structure to be modified. 1230 * @shmflg contains the operation control flags. 1231 * Return 0 if permission is granted. 1232 * @shm_shmctl: 1233 * Check permission when a shared memory control operation specified by 1234 * @cmd is to be performed on the shared memory region @shp. 1235 * The @shp may be NULL, e.g. for IPC_INFO or SHM_INFO. 1236 * @shp contains shared memory structure to be modified. 1237 * @cmd contains the operation to be performed. 1238 * Return 0 if permission is granted. 1239 * @shm_shmat: 1240 * Check permissions prior to allowing the shmat system call to attach the 1241 * shared memory segment @shp to the data segment of the calling process. 1242 * The attaching address is specified by @shmaddr. 1243 * @shp contains the shared memory structure to be modified. 1244 * @shmaddr contains the address to attach memory region to. 1245 * @shmflg contains the operational flags. 1246 * Return 0 if permission is granted. 1247 * 1248 * Security hooks for System V Semaphores 1249 * 1250 * @sem_alloc_security: 1251 * Allocate and attach a security structure to the sma->sem_perm.security 1252 * field. The security field is initialized to NULL when the structure is 1253 * first created. 1254 * @sma contains the semaphore structure 1255 * Return 0 if operation was successful and permission is granted. 1256 * @sem_free_security: 1257 * deallocate security struct for this semaphore 1258 * @sma contains the semaphore structure. 1259 * @sem_associate: 1260 * Check permission when a semaphore is requested through the semget 1261 * system call. This hook is only called when returning the semaphore 1262 * identifier for an existing semaphore, not when a new one must be 1263 * created. 1264 * @sma contains the semaphore structure. 1265 * @semflg contains the operation control flags. 1266 * Return 0 if permission is granted. 1267 * @sem_semctl: 1268 * Check permission when a semaphore operation specified by @cmd is to be 1269 * performed on the semaphore @sma. The @sma may be NULL, e.g. for 1270 * IPC_INFO or SEM_INFO. 1271 * @sma contains the semaphore structure. May be NULL. 1272 * @cmd contains the operation to be performed. 1273 * Return 0 if permission is granted. 1274 * @sem_semop 1275 * Check permissions before performing operations on members of the 1276 * semaphore set @sma. If the @alter flag is nonzero, the semaphore set 1277 * may be modified. 1278 * @sma contains the semaphore structure. 1279 * @sops contains the operations to perform. 1280 * @nsops contains the number of operations to perform. 1281 * @alter contains the flag indicating whether changes are to be made. 1282 * Return 0 if permission is granted. 1283 * 1284 * @binder_set_context_mgr 1285 * Check whether @mgr is allowed to be the binder context manager. 1286 * @mgr contains the task_struct for the task being registered. 1287 * Return 0 if permission is granted. 1288 * @binder_transaction 1289 * Check whether @from is allowed to invoke a binder transaction call 1290 * to @to. 1291 * @from contains the task_struct for the sending task. 1292 * @to contains the task_struct for the receiving task. 1293 * @binder_transfer_binder 1294 * Check whether @from is allowed to transfer a binder reference to @to. 1295 * @from contains the task_struct for the sending task. 1296 * @to contains the task_struct for the receiving task. 1297 * @binder_transfer_file 1298 * Check whether @from is allowed to transfer @file to @to. 1299 * @from contains the task_struct for the sending task. 1300 * @file contains the struct file being transferred. 1301 * @to contains the task_struct for the receiving task. 1302 * 1303 * @ptrace_access_check: 1304 * Check permission before allowing the current process to trace the 1305 * @child process. 1306 * Security modules may also want to perform a process tracing check 1307 * during an execve in the set_security or apply_creds hooks of 1308 * tracing check during an execve in the bprm_set_creds hook of 1309 * binprm_security_ops if the process is being traced and its security 1310 * attributes would be changed by the execve. 1311 * @child contains the task_struct structure for the target process. 1312 * @mode contains the PTRACE_MODE flags indicating the form of access. 1313 * Return 0 if permission is granted. 1314 * @ptrace_traceme: 1315 * Check that the @parent process has sufficient permission to trace the 1316 * current process before allowing the current process to present itself 1317 * to the @parent process for tracing. 1318 * @parent contains the task_struct structure for debugger process. 1319 * Return 0 if permission is granted. 1320 * @capget: 1321 * Get the @effective, @inheritable, and @permitted capability sets for 1322 * the @target process. The hook may also perform permission checking to 1323 * determine if the current process is allowed to see the capability sets 1324 * of the @target process. 1325 * @target contains the task_struct structure for target process. 1326 * @effective contains the effective capability set. 1327 * @inheritable contains the inheritable capability set. 1328 * @permitted contains the permitted capability set. 1329 * Return 0 if the capability sets were successfully obtained. 1330 * @capset: 1331 * Set the @effective, @inheritable, and @permitted capability sets for 1332 * the current process. 1333 * @new contains the new credentials structure for target process. 1334 * @old contains the current credentials structure for target process. 1335 * @effective contains the effective capability set. 1336 * @inheritable contains the inheritable capability set. 1337 * @permitted contains the permitted capability set. 1338 * Return 0 and update @new if permission is granted. 1339 * @capable: 1340 * Check whether the @tsk process has the @cap capability in the indicated 1341 * credentials. 1342 * @cred contains the credentials to use. 1343 * @ns contains the user namespace we want the capability in 1344 * @cap contains the capability <include/linux/capability.h>. 1345 * @audit: Whether to write an audit message or not 1346 * Return 0 if the capability is granted for @tsk. 1347 * @syslog: 1348 * Check permission before accessing the kernel message ring or changing 1349 * logging to the console. 1350 * See the syslog(2) manual page for an explanation of the @type values. 1351 * @type contains the type of action. 1352 * @from_file indicates the context of action (if it came from /proc). 1353 * Return 0 if permission is granted. 1354 * @settime: 1355 * Check permission to change the system time. 1356 * struct timespec and timezone are defined in include/linux/time.h 1357 * @ts contains new time 1358 * @tz contains new timezone 1359 * Return 0 if permission is granted. 1360 * @vm_enough_memory: 1361 * Check permissions for allocating a new virtual mapping. 1362 * @mm contains the mm struct it is being added to. 1363 * @pages contains the number of pages. 1364 * Return 0 if permission is granted. 1365 * 1366 * @ismaclabel: 1367 * Check if the extended attribute specified by @name 1368 * represents a MAC label. Returns 1 if name is a MAC 1369 * attribute otherwise returns 0. 1370 * @name full extended attribute name to check against 1371 * LSM as a MAC label. 1372 * 1373 * @secid_to_secctx: 1374 * Convert secid to security context. If secdata is NULL the length of 1375 * the result will be returned in seclen, but no secdata will be returned. 1376 * This does mean that the length could change between calls to check the 1377 * length and the next call which actually allocates and returns the secdata. 1378 * @secid contains the security ID. 1379 * @secdata contains the pointer that stores the converted security context. 1380 * @seclen pointer which contains the length of the data 1381 * @secctx_to_secid: 1382 * Convert security context to secid. 1383 * @secid contains the pointer to the generated security ID. 1384 * @secdata contains the security context. 1385 * 1386 * @release_secctx: 1387 * Release the security context. 1388 * @secdata contains the security context. 1389 * @seclen contains the length of the security context. 1390 * 1391 * Security hooks for Audit 1392 * 1393 * @audit_rule_init: 1394 * Allocate and initialize an LSM audit rule structure. 1395 * @field contains the required Audit action. Fields flags are defined in include/linux/audit.h 1396 * @op contains the operator the rule uses. 1397 * @rulestr contains the context where the rule will be applied to. 1398 * @lsmrule contains a pointer to receive the result. 1399 * Return 0 if @lsmrule has been successfully set, 1400 * -EINVAL in case of an invalid rule. 1401 * 1402 * @audit_rule_known: 1403 * Specifies whether given @rule contains any fields related to current LSM. 1404 * @rule contains the audit rule of interest. 1405 * Return 1 in case of relation found, 0 otherwise. 1406 * 1407 * @audit_rule_match: 1408 * Determine if given @secid matches a rule previously approved 1409 * by @audit_rule_known. 1410 * @secid contains the security id in question. 1411 * @field contains the field which relates to current LSM. 1412 * @op contains the operator that will be used for matching. 1413 * @rule points to the audit rule that will be checked against. 1414 * @actx points to the audit context associated with the check. 1415 * Return 1 if secid matches the rule, 0 if it does not, -ERRNO on failure. 1416 * 1417 * @audit_rule_free: 1418 * Deallocate the LSM audit rule structure previously allocated by 1419 * audit_rule_init. 1420 * @rule contains the allocated rule 1421 * 1422 * @inode_notifysecctx: 1423 * Notify the security module of what the security context of an inode 1424 * should be. Initializes the incore security context managed by the 1425 * security module for this inode. Example usage: NFS client invokes 1426 * this hook to initialize the security context in its incore inode to the 1427 * value provided by the server for the file when the server returned the 1428 * file's attributes to the client. 1429 * 1430 * Must be called with inode->i_mutex locked. 1431 * 1432 * @inode we wish to set the security context of. 1433 * @ctx contains the string which we wish to set in the inode. 1434 * @ctxlen contains the length of @ctx. 1435 * 1436 * @inode_setsecctx: 1437 * Change the security context of an inode. Updates the 1438 * incore security context managed by the security module and invokes the 1439 * fs code as needed (via __vfs_setxattr_noperm) to update any backing 1440 * xattrs that represent the context. Example usage: NFS server invokes 1441 * this hook to change the security context in its incore inode and on the 1442 * backing filesystem to a value provided by the client on a SETATTR 1443 * operation. 1444 * 1445 * Must be called with inode->i_mutex locked. 1446 * 1447 * @dentry contains the inode we wish to set the security context of. 1448 * @ctx contains the string which we wish to set in the inode. 1449 * @ctxlen contains the length of @ctx. 1450 * 1451 * @inode_getsecctx: 1452 * On success, returns 0 and fills out @ctx and @ctxlen with the security 1453 * context for the given @inode. 1454 * 1455 * @inode we wish to get the security context of. 1456 * @ctx is a pointer in which to place the allocated security context. 1457 * @ctxlen points to the place to put the length of @ctx. 1458 * This is the main security structure. 1459 */ 1460struct security_operations { 1461 char name[SECURITY_NAME_MAX + 1]; 1462 1463 int (*binder_set_context_mgr) (struct task_struct *mgr); 1464 int (*binder_transaction) (struct task_struct *from, 1465 struct task_struct *to); 1466 int (*binder_transfer_binder) (struct task_struct *from, 1467 struct task_struct *to); 1468 int (*binder_transfer_file) (struct task_struct *from, 1469 struct task_struct *to, struct file *file); 1470 1471 int (*ptrace_access_check) (struct task_struct *child, unsigned int mode); 1472 int (*ptrace_traceme) (struct task_struct *parent); 1473 int (*capget) (struct task_struct *target, 1474 kernel_cap_t *effective, 1475 kernel_cap_t *inheritable, kernel_cap_t *permitted); 1476 int (*capset) (struct cred *new, 1477 const struct cred *old, 1478 const kernel_cap_t *effective, 1479 const kernel_cap_t *inheritable, 1480 const kernel_cap_t *permitted); 1481 int (*capable) (const struct cred *cred, struct user_namespace *ns, 1482 int cap, int audit); 1483 int (*quotactl) (int cmds, int type, int id, struct super_block *sb); 1484 int (*quota_on) (struct dentry *dentry); 1485 int (*syslog) (int type); 1486 int (*settime) (const struct timespec *ts, const struct timezone *tz); 1487 int (*vm_enough_memory) (struct mm_struct *mm, long pages); 1488 1489 int (*bprm_set_creds) (struct linux_binprm *bprm); 1490 int (*bprm_check_security) (struct linux_binprm *bprm); 1491 int (*bprm_secureexec) (struct linux_binprm *bprm); 1492 void (*bprm_committing_creds) (struct linux_binprm *bprm); 1493 void (*bprm_committed_creds) (struct linux_binprm *bprm); 1494 1495 int (*sb_alloc_security) (struct super_block *sb); 1496 void (*sb_free_security) (struct super_block *sb); 1497 int (*sb_copy_data) (char *orig, char *copy); 1498 int (*sb_remount) (struct super_block *sb, void *data); 1499 int (*sb_kern_mount) (struct super_block *sb, int flags, void *data); 1500 int (*sb_show_options) (struct seq_file *m, struct super_block *sb); 1501 int (*sb_statfs) (struct dentry *dentry); 1502 int (*sb_mount) (const char *dev_name, struct path *path, 1503 const char *type, unsigned long flags, void *data); 1504 int (*sb_umount) (struct vfsmount *mnt, int flags); 1505 int (*sb_pivotroot) (struct path *old_path, 1506 struct path *new_path); 1507 int (*sb_set_mnt_opts) (struct super_block *sb, 1508 struct security_mnt_opts *opts, 1509 unsigned long kern_flags, 1510 unsigned long *set_kern_flags); 1511 int (*sb_clone_mnt_opts) (const struct super_block *oldsb, 1512 struct super_block *newsb); 1513 int (*sb_parse_opts_str) (char *options, struct security_mnt_opts *opts); 1514 int (*dentry_init_security) (struct dentry *dentry, int mode, 1515 struct qstr *name, void **ctx, 1516 u32 *ctxlen); 1517 1518 1519#ifdef CONFIG_SECURITY_PATH 1520 int (*path_unlink) (struct path *dir, struct dentry *dentry); 1521 int (*path_mkdir) (struct path *dir, struct dentry *dentry, umode_t mode); 1522 int (*path_rmdir) (struct path *dir, struct dentry *dentry); 1523 int (*path_mknod) (struct path *dir, struct dentry *dentry, umode_t mode, 1524 unsigned int dev); 1525 int (*path_truncate) (struct path *path); 1526 int (*path_symlink) (struct path *dir, struct dentry *dentry, 1527 const char *old_name); 1528 int (*path_link) (struct dentry *old_dentry, struct path *new_dir, 1529 struct dentry *new_dentry); 1530 int (*path_rename) (struct path *old_dir, struct dentry *old_dentry, 1531 struct path *new_dir, struct dentry *new_dentry); 1532 int (*path_chmod) (struct path *path, umode_t mode); 1533 int (*path_chown) (struct path *path, kuid_t uid, kgid_t gid); 1534 int (*path_chroot) (struct path *path); 1535#endif 1536 1537 int (*inode_alloc_security) (struct inode *inode); 1538 void (*inode_free_security) (struct inode *inode); 1539 int (*inode_init_security) (struct inode *inode, struct inode *dir, 1540 const struct qstr *qstr, const char **name, 1541 void **value, size_t *len); 1542 int (*inode_create) (struct inode *dir, 1543 struct dentry *dentry, umode_t mode); 1544 int (*inode_link) (struct dentry *old_dentry, 1545 struct inode *dir, struct dentry *new_dentry); 1546 int (*inode_unlink) (struct inode *dir, struct dentry *dentry); 1547 int (*inode_symlink) (struct inode *dir, 1548 struct dentry *dentry, const char *old_name); 1549 int (*inode_mkdir) (struct inode *dir, struct dentry *dentry, umode_t mode); 1550 int (*inode_rmdir) (struct inode *dir, struct dentry *dentry); 1551 int (*inode_mknod) (struct inode *dir, struct dentry *dentry, 1552 umode_t mode, dev_t dev); 1553 int (*inode_rename) (struct inode *old_dir, struct dentry *old_dentry, 1554 struct inode *new_dir, struct dentry *new_dentry); 1555 int (*inode_readlink) (struct dentry *dentry); 1556 int (*inode_follow_link) (struct dentry *dentry, struct nameidata *nd); 1557 int (*inode_permission) (struct inode *inode, int mask); 1558 int (*inode_setattr) (struct dentry *dentry, struct iattr *attr); 1559 int (*inode_getattr) (const struct path *path); 1560 int (*inode_setxattr) (struct dentry *dentry, const char *name, 1561 const void *value, size_t size, int flags); 1562 void (*inode_post_setxattr) (struct dentry *dentry, const char *name, 1563 const void *value, size_t size, int flags); 1564 int (*inode_getxattr) (struct dentry *dentry, const char *name); 1565 int (*inode_listxattr) (struct dentry *dentry); 1566 int (*inode_removexattr) (struct dentry *dentry, const char *name); 1567 int (*inode_need_killpriv) (struct dentry *dentry); 1568 int (*inode_killpriv) (struct dentry *dentry); 1569 int (*inode_getsecurity) (const struct inode *inode, const char *name, void **buffer, bool alloc); 1570 int (*inode_setsecurity) (struct inode *inode, const char *name, const void *value, size_t size, int flags); 1571 int (*inode_listsecurity) (struct inode *inode, char *buffer, size_t buffer_size); 1572 void (*inode_getsecid) (const struct inode *inode, u32 *secid); 1573 1574 int (*file_permission) (struct file *file, int mask); 1575 int (*file_alloc_security) (struct file *file); 1576 void (*file_free_security) (struct file *file); 1577 int (*file_ioctl) (struct file *file, unsigned int cmd, 1578 unsigned long arg); 1579 int (*mmap_addr) (unsigned long addr); 1580 int (*mmap_file) (struct file *file, 1581 unsigned long reqprot, unsigned long prot, 1582 unsigned long flags); 1583 int (*file_mprotect) (struct vm_area_struct *vma, 1584 unsigned long reqprot, 1585 unsigned long prot); 1586 int (*file_lock) (struct file *file, unsigned int cmd); 1587 int (*file_fcntl) (struct file *file, unsigned int cmd, 1588 unsigned long arg); 1589 void (*file_set_fowner) (struct file *file); 1590 int (*file_send_sigiotask) (struct task_struct *tsk, 1591 struct fown_struct *fown, int sig); 1592 int (*file_receive) (struct file *file); 1593 int (*file_open) (struct file *file, const struct cred *cred); 1594 1595 int (*task_create) (unsigned long clone_flags); 1596 void (*task_free) (struct task_struct *task); 1597 int (*cred_alloc_blank) (struct cred *cred, gfp_t gfp); 1598 void (*cred_free) (struct cred *cred); 1599 int (*cred_prepare)(struct cred *new, const struct cred *old, 1600 gfp_t gfp); 1601 void (*cred_transfer)(struct cred *new, const struct cred *old); 1602 int (*kernel_act_as)(struct cred *new, u32 secid); 1603 int (*kernel_create_files_as)(struct cred *new, struct inode *inode); 1604 int (*kernel_fw_from_file)(struct file *file, char *buf, size_t size); 1605 int (*kernel_module_request)(char *kmod_name); 1606 int (*kernel_module_from_file)(struct file *file); 1607 int (*task_fix_setuid) (struct cred *new, const struct cred *old, 1608 int flags); 1609 int (*task_setpgid) (struct task_struct *p, pid_t pgid); 1610 int (*task_getpgid) (struct task_struct *p); 1611 int (*task_getsid) (struct task_struct *p); 1612 void (*task_getsecid) (struct task_struct *p, u32 *secid); 1613 int (*task_setnice) (struct task_struct *p, int nice); 1614 int (*task_setioprio) (struct task_struct *p, int ioprio); 1615 int (*task_getioprio) (struct task_struct *p); 1616 int (*task_setrlimit) (struct task_struct *p, unsigned int resource, 1617 struct rlimit *new_rlim); 1618 int (*task_setscheduler) (struct task_struct *p); 1619 int (*task_getscheduler) (struct task_struct *p); 1620 int (*task_movememory) (struct task_struct *p); 1621 int (*task_kill) (struct task_struct *p, 1622 struct siginfo *info, int sig, u32 secid); 1623 int (*task_wait) (struct task_struct *p); 1624 int (*task_prctl) (int option, unsigned long arg2, 1625 unsigned long arg3, unsigned long arg4, 1626 unsigned long arg5); 1627 void (*task_to_inode) (struct task_struct *p, struct inode *inode); 1628 1629 int (*ipc_permission) (struct kern_ipc_perm *ipcp, short flag); 1630 void (*ipc_getsecid) (struct kern_ipc_perm *ipcp, u32 *secid); 1631 1632 int (*msg_msg_alloc_security) (struct msg_msg *msg); 1633 void (*msg_msg_free_security) (struct msg_msg *msg); 1634 1635 int (*msg_queue_alloc_security) (struct msg_queue *msq); 1636 void (*msg_queue_free_security) (struct msg_queue *msq); 1637 int (*msg_queue_associate) (struct msg_queue *msq, int msqflg); 1638 int (*msg_queue_msgctl) (struct msg_queue *msq, int cmd); 1639 int (*msg_queue_msgsnd) (struct msg_queue *msq, 1640 struct msg_msg *msg, int msqflg); 1641 int (*msg_queue_msgrcv) (struct msg_queue *msq, 1642 struct msg_msg *msg, 1643 struct task_struct *target, 1644 long type, int mode); 1645 1646 int (*shm_alloc_security) (struct shmid_kernel *shp); 1647 void (*shm_free_security) (struct shmid_kernel *shp); 1648 int (*shm_associate) (struct shmid_kernel *shp, int shmflg); 1649 int (*shm_shmctl) (struct shmid_kernel *shp, int cmd); 1650 int (*shm_shmat) (struct shmid_kernel *shp, 1651 char __user *shmaddr, int shmflg); 1652 1653 int (*sem_alloc_security) (struct sem_array *sma); 1654 void (*sem_free_security) (struct sem_array *sma); 1655 int (*sem_associate) (struct sem_array *sma, int semflg); 1656 int (*sem_semctl) (struct sem_array *sma, int cmd); 1657 int (*sem_semop) (struct sem_array *sma, 1658 struct sembuf *sops, unsigned nsops, int alter); 1659 1660 int (*netlink_send) (struct sock *sk, struct sk_buff *skb); 1661 1662 void (*d_instantiate) (struct dentry *dentry, struct inode *inode); 1663 1664 int (*getprocattr) (struct task_struct *p, char *name, char **value); 1665 int (*setprocattr) (struct task_struct *p, char *name, void *value, size_t size); 1666 int (*ismaclabel) (const char *name); 1667 int (*secid_to_secctx) (u32 secid, char **secdata, u32 *seclen); 1668 int (*secctx_to_secid) (const char *secdata, u32 seclen, u32 *secid); 1669 void (*release_secctx) (char *secdata, u32 seclen); 1670 1671 int (*inode_notifysecctx)(struct inode *inode, void *ctx, u32 ctxlen); 1672 int (*inode_setsecctx)(struct dentry *dentry, void *ctx, u32 ctxlen); 1673 int (*inode_getsecctx)(struct inode *inode, void **ctx, u32 *ctxlen); 1674 1675#ifdef CONFIG_SECURITY_NETWORK 1676 int (*unix_stream_connect) (struct sock *sock, struct sock *other, struct sock *newsk); 1677 int (*unix_may_send) (struct socket *sock, struct socket *other); 1678 1679 int (*socket_create) (int family, int type, int protocol, int kern); 1680 int (*socket_post_create) (struct socket *sock, int family, 1681 int type, int protocol, int kern); 1682 int (*socket_bind) (struct socket *sock, 1683 struct sockaddr *address, int addrlen); 1684 int (*socket_connect) (struct socket *sock, 1685 struct sockaddr *address, int addrlen); 1686 int (*socket_listen) (struct socket *sock, int backlog); 1687 int (*socket_accept) (struct socket *sock, struct socket *newsock); 1688 int (*socket_sendmsg) (struct socket *sock, 1689 struct msghdr *msg, int size); 1690 int (*socket_recvmsg) (struct socket *sock, 1691 struct msghdr *msg, int size, int flags); 1692 int (*socket_getsockname) (struct socket *sock); 1693 int (*socket_getpeername) (struct socket *sock); 1694 int (*socket_getsockopt) (struct socket *sock, int level, int optname); 1695 int (*socket_setsockopt) (struct socket *sock, int level, int optname); 1696 int (*socket_shutdown) (struct socket *sock, int how); 1697 int (*socket_sock_rcv_skb) (struct sock *sk, struct sk_buff *skb); 1698 int (*socket_getpeersec_stream) (struct socket *sock, char __user *optval, int __user *optlen, unsigned len); 1699 int (*socket_getpeersec_dgram) (struct socket *sock, struct sk_buff *skb, u32 *secid); 1700 int (*sk_alloc_security) (struct sock *sk, int family, gfp_t priority); 1701 void (*sk_free_security) (struct sock *sk); 1702 void (*sk_clone_security) (const struct sock *sk, struct sock *newsk); 1703 void (*sk_getsecid) (struct sock *sk, u32 *secid); 1704 void (*sock_graft) (struct sock *sk, struct socket *parent); 1705 int (*inet_conn_request) (struct sock *sk, struct sk_buff *skb, 1706 struct request_sock *req); 1707 void (*inet_csk_clone) (struct sock *newsk, const struct request_sock *req); 1708 void (*inet_conn_established) (struct sock *sk, struct sk_buff *skb); 1709 int (*secmark_relabel_packet) (u32 secid); 1710 void (*secmark_refcount_inc) (void); 1711 void (*secmark_refcount_dec) (void); 1712 void (*req_classify_flow) (const struct request_sock *req, struct flowi *fl); 1713 int (*tun_dev_alloc_security) (void **security); 1714 void (*tun_dev_free_security) (void *security); 1715 int (*tun_dev_create) (void); 1716 int (*tun_dev_attach_queue) (void *security); 1717 int (*tun_dev_attach) (struct sock *sk, void *security); 1718 int (*tun_dev_open) (void *security); 1719#endif /* CONFIG_SECURITY_NETWORK */ 1720 1721#ifdef CONFIG_SECURITY_NETWORK_XFRM 1722 int (*xfrm_policy_alloc_security) (struct xfrm_sec_ctx **ctxp, 1723 struct xfrm_user_sec_ctx *sec_ctx, gfp_t gfp); 1724 int (*xfrm_policy_clone_security) (struct xfrm_sec_ctx *old_ctx, struct xfrm_sec_ctx **new_ctx); 1725 void (*xfrm_policy_free_security) (struct xfrm_sec_ctx *ctx); 1726 int (*xfrm_policy_delete_security) (struct xfrm_sec_ctx *ctx); 1727 int (*xfrm_state_alloc) (struct xfrm_state *x, 1728 struct xfrm_user_sec_ctx *sec_ctx); 1729 int (*xfrm_state_alloc_acquire) (struct xfrm_state *x, 1730 struct xfrm_sec_ctx *polsec, 1731 u32 secid); 1732 void (*xfrm_state_free_security) (struct xfrm_state *x); 1733 int (*xfrm_state_delete_security) (struct xfrm_state *x); 1734 int (*xfrm_policy_lookup) (struct xfrm_sec_ctx *ctx, u32 fl_secid, u8 dir); 1735 int (*xfrm_state_pol_flow_match) (struct xfrm_state *x, 1736 struct xfrm_policy *xp, 1737 const struct flowi *fl); 1738 int (*xfrm_decode_session) (struct sk_buff *skb, u32 *secid, int ckall); 1739#endif /* CONFIG_SECURITY_NETWORK_XFRM */ 1740 1741 /* key management security hooks */ 1742#ifdef CONFIG_KEYS 1743 int (*key_alloc) (struct key *key, const struct cred *cred, unsigned long flags); 1744 void (*key_free) (struct key *key); 1745 int (*key_permission) (key_ref_t key_ref, 1746 const struct cred *cred, 1747 unsigned perm); 1748 int (*key_getsecurity)(struct key *key, char **_buffer); 1749#endif /* CONFIG_KEYS */ 1750 1751#ifdef CONFIG_AUDIT 1752 int (*audit_rule_init) (u32 field, u32 op, char *rulestr, void **lsmrule); 1753 int (*audit_rule_known) (struct audit_krule *krule); 1754 int (*audit_rule_match) (u32 secid, u32 field, u32 op, void *lsmrule, 1755 struct audit_context *actx); 1756 void (*audit_rule_free) (void *lsmrule); 1757#endif /* CONFIG_AUDIT */ 1758}; 1759 1760/* prototypes */ 1761extern int security_init(void); 1762extern int security_module_enable(struct security_operations *ops); 1763extern int register_security(struct security_operations *ops); 1764extern void __init security_fixup_ops(struct security_operations *ops); 1765 1766 1767/* Security operations */ 1768int security_binder_set_context_mgr(struct task_struct *mgr); 1769int security_binder_transaction(struct task_struct *from, 1770 struct task_struct *to); 1771int security_binder_transfer_binder(struct task_struct *from, 1772 struct task_struct *to); 1773int security_binder_transfer_file(struct task_struct *from, 1774 struct task_struct *to, struct file *file); 1775int security_ptrace_access_check(struct task_struct *child, unsigned int mode); 1776int security_ptrace_traceme(struct task_struct *parent); 1777int security_capget(struct task_struct *target, 1778 kernel_cap_t *effective, 1779 kernel_cap_t *inheritable, 1780 kernel_cap_t *permitted); 1781int security_capset(struct cred *new, const struct cred *old, 1782 const kernel_cap_t *effective, 1783 const kernel_cap_t *inheritable, 1784 const kernel_cap_t *permitted); 1785int security_capable(const struct cred *cred, struct user_namespace *ns, 1786 int cap); 1787int security_capable_noaudit(const struct cred *cred, struct user_namespace *ns, 1788 int cap); 1789int security_quotactl(int cmds, int type, int id, struct super_block *sb); 1790int security_quota_on(struct dentry *dentry); 1791int security_syslog(int type); 1792int security_settime(const struct timespec *ts, const struct timezone *tz); 1793int security_vm_enough_memory_mm(struct mm_struct *mm, long pages); 1794int security_bprm_set_creds(struct linux_binprm *bprm); 1795int security_bprm_check(struct linux_binprm *bprm); 1796void security_bprm_committing_creds(struct linux_binprm *bprm); 1797void security_bprm_committed_creds(struct linux_binprm *bprm); 1798int security_bprm_secureexec(struct linux_binprm *bprm); 1799int security_sb_alloc(struct super_block *sb); 1800void security_sb_free(struct super_block *sb); 1801int security_sb_copy_data(char *orig, char *copy); 1802int security_sb_remount(struct super_block *sb, void *data); 1803int security_sb_kern_mount(struct super_block *sb, int flags, void *data); 1804int security_sb_show_options(struct seq_file *m, struct super_block *sb); 1805int security_sb_statfs(struct dentry *dentry); 1806int security_sb_mount(const char *dev_name, struct path *path, 1807 const char *type, unsigned long flags, void *data); 1808int security_sb_umount(struct vfsmount *mnt, int flags); 1809int security_sb_pivotroot(struct path *old_path, struct path *new_path); 1810int security_sb_set_mnt_opts(struct super_block *sb, 1811 struct security_mnt_opts *opts, 1812 unsigned long kern_flags, 1813 unsigned long *set_kern_flags); 1814int security_sb_clone_mnt_opts(const struct super_block *oldsb, 1815 struct super_block *newsb); 1816int security_sb_parse_opts_str(char *options, struct security_mnt_opts *opts); 1817int security_dentry_init_security(struct dentry *dentry, int mode, 1818 struct qstr *name, void **ctx, 1819 u32 *ctxlen); 1820 1821int security_inode_alloc(struct inode *inode); 1822void security_inode_free(struct inode *inode); 1823int security_inode_init_security(struct inode *inode, struct inode *dir, 1824 const struct qstr *qstr, 1825 initxattrs initxattrs, void *fs_data); 1826int security_old_inode_init_security(struct inode *inode, struct inode *dir, 1827 const struct qstr *qstr, const char **name, 1828 void **value, size_t *len); 1829int security_inode_create(struct inode *dir, struct dentry *dentry, umode_t mode); 1830int security_inode_link(struct dentry *old_dentry, struct inode *dir, 1831 struct dentry *new_dentry); 1832int security_inode_unlink(struct inode *dir, struct dentry *dentry); 1833int security_inode_symlink(struct inode *dir, struct dentry *dentry, 1834 const char *old_name); 1835int security_inode_mkdir(struct inode *dir, struct dentry *dentry, umode_t mode); 1836int security_inode_rmdir(struct inode *dir, struct dentry *dentry); 1837int security_inode_mknod(struct inode *dir, struct dentry *dentry, umode_t mode, dev_t dev); 1838int security_inode_rename(struct inode *old_dir, struct dentry *old_dentry, 1839 struct inode *new_dir, struct dentry *new_dentry, 1840 unsigned int flags); 1841int security_inode_readlink(struct dentry *dentry); 1842int security_inode_follow_link(struct dentry *dentry, struct nameidata *nd); 1843int security_inode_permission(struct inode *inode, int mask); 1844int security_inode_setattr(struct dentry *dentry, struct iattr *attr); 1845int security_inode_getattr(const struct path *path); 1846int security_inode_setxattr(struct dentry *dentry, const char *name, 1847 const void *value, size_t size, int flags); 1848void security_inode_post_setxattr(struct dentry *dentry, const char *name, 1849 const void *value, size_t size, int flags); 1850int security_inode_getxattr(struct dentry *dentry, const char *name); 1851int security_inode_listxattr(struct dentry *dentry); 1852int security_inode_removexattr(struct dentry *dentry, const char *name); 1853int security_inode_need_killpriv(struct dentry *dentry); 1854int security_inode_killpriv(struct dentry *dentry); 1855int security_inode_getsecurity(const struct inode *inode, const char *name, void **buffer, bool alloc); 1856int security_inode_setsecurity(struct inode *inode, const char *name, const void *value, size_t size, int flags); 1857int security_inode_listsecurity(struct inode *inode, char *buffer, size_t buffer_size); 1858void security_inode_getsecid(const struct inode *inode, u32 *secid); 1859int security_file_permission(struct file *file, int mask); 1860int security_file_alloc(struct file *file); 1861void security_file_free(struct file *file); 1862int security_file_ioctl(struct file *file, unsigned int cmd, unsigned long arg); 1863int security_mmap_file(struct file *file, unsigned long prot, 1864 unsigned long flags); 1865int security_mmap_addr(unsigned long addr); 1866int security_file_mprotect(struct vm_area_struct *vma, unsigned long reqprot, 1867 unsigned long prot); 1868int security_file_lock(struct file *file, unsigned int cmd); 1869int security_file_fcntl(struct file *file, unsigned int cmd, unsigned long arg); 1870void security_file_set_fowner(struct file *file); 1871int security_file_send_sigiotask(struct task_struct *tsk, 1872 struct fown_struct *fown, int sig); 1873int security_file_receive(struct file *file); 1874int security_file_open(struct file *file, const struct cred *cred); 1875int security_task_create(unsigned long clone_flags); 1876void security_task_free(struct task_struct *task); 1877int security_cred_alloc_blank(struct cred *cred, gfp_t gfp); 1878void security_cred_free(struct cred *cred); 1879int security_prepare_creds(struct cred *new, const struct cred *old, gfp_t gfp); 1880void security_transfer_creds(struct cred *new, const struct cred *old); 1881int security_kernel_act_as(struct cred *new, u32 secid); 1882int security_kernel_create_files_as(struct cred *new, struct inode *inode); 1883int security_kernel_fw_from_file(struct file *file, char *buf, size_t size); 1884int security_kernel_module_request(char *kmod_name); 1885int security_kernel_module_from_file(struct file *file); 1886int security_task_fix_setuid(struct cred *new, const struct cred *old, 1887 int flags); 1888int security_task_setpgid(struct task_struct *p, pid_t pgid); 1889int security_task_getpgid(struct task_struct *p); 1890int security_task_getsid(struct task_struct *p); 1891void security_task_getsecid(struct task_struct *p, u32 *secid); 1892int security_task_setnice(struct task_struct *p, int nice); 1893int security_task_setioprio(struct task_struct *p, int ioprio); 1894int security_task_getioprio(struct task_struct *p); 1895int security_task_setrlimit(struct task_struct *p, unsigned int resource, 1896 struct rlimit *new_rlim); 1897int security_task_setscheduler(struct task_struct *p); 1898int security_task_getscheduler(struct task_struct *p); 1899int security_task_movememory(struct task_struct *p); 1900int security_task_kill(struct task_struct *p, struct siginfo *info, 1901 int sig, u32 secid); 1902int security_task_wait(struct task_struct *p); 1903int security_task_prctl(int option, unsigned long arg2, unsigned long arg3, 1904 unsigned long arg4, unsigned long arg5); 1905void security_task_to_inode(struct task_struct *p, struct inode *inode); 1906int security_ipc_permission(struct kern_ipc_perm *ipcp, short flag); 1907void security_ipc_getsecid(struct kern_ipc_perm *ipcp, u32 *secid); 1908int security_msg_msg_alloc(struct msg_msg *msg); 1909void security_msg_msg_free(struct msg_msg *msg); 1910int security_msg_queue_alloc(struct msg_queue *msq); 1911void security_msg_queue_free(struct msg_queue *msq); 1912int security_msg_queue_associate(struct msg_queue *msq, int msqflg); 1913int security_msg_queue_msgctl(struct msg_queue *msq, int cmd); 1914int security_msg_queue_msgsnd(struct msg_queue *msq, 1915 struct msg_msg *msg, int msqflg); 1916int security_msg_queue_msgrcv(struct msg_queue *msq, struct msg_msg *msg, 1917 struct task_struct *target, long type, int mode); 1918int security_shm_alloc(struct shmid_kernel *shp); 1919void security_shm_free(struct shmid_kernel *shp); 1920int security_shm_associate(struct shmid_kernel *shp, int shmflg); 1921int security_shm_shmctl(struct shmid_kernel *shp, int cmd); 1922int security_shm_shmat(struct shmid_kernel *shp, char __user *shmaddr, int shmflg); 1923int security_sem_alloc(struct sem_array *sma); 1924void security_sem_free(struct sem_array *sma); 1925int security_sem_associate(struct sem_array *sma, int semflg); 1926int security_sem_semctl(struct sem_array *sma, int cmd); 1927int security_sem_semop(struct sem_array *sma, struct sembuf *sops, 1928 unsigned nsops, int alter); 1929void security_d_instantiate(struct dentry *dentry, struct inode *inode); 1930int security_getprocattr(struct task_struct *p, char *name, char **value); 1931int security_setprocattr(struct task_struct *p, char *name, void *value, size_t size); 1932int security_netlink_send(struct sock *sk, struct sk_buff *skb); 1933int security_ismaclabel(const char *name); 1934int security_secid_to_secctx(u32 secid, char **secdata, u32 *seclen); 1935int security_secctx_to_secid(const char *secdata, u32 seclen, u32 *secid); 1936void security_release_secctx(char *secdata, u32 seclen); 1937 1938int security_inode_notifysecctx(struct inode *inode, void *ctx, u32 ctxlen); 1939int security_inode_setsecctx(struct dentry *dentry, void *ctx, u32 ctxlen); 1940int security_inode_getsecctx(struct inode *inode, void **ctx, u32 *ctxlen); 1941#else /* CONFIG_SECURITY */ 1942struct security_mnt_opts { 1943}; 1944 1945static inline void security_init_mnt_opts(struct security_mnt_opts *opts) 1946{ 1947} 1948 1949static inline void security_free_mnt_opts(struct security_mnt_opts *opts) 1950{ 1951} 1952 1953/* 1954 * This is the default capabilities functionality. Most of these functions 1955 * are just stubbed out, but a few must call the proper capable code. 1956 */ 1957 1958static inline int security_init(void) 1959{ 1960 return 0; 1961} 1962 1963static inline int security_binder_set_context_mgr(struct task_struct *mgr) 1964{ 1965 return 0; 1966} 1967 1968static inline int security_binder_transaction(struct task_struct *from, 1969 struct task_struct *to) 1970{ 1971 return 0; 1972} 1973 1974static inline int security_binder_transfer_binder(struct task_struct *from, 1975 struct task_struct *to) 1976{ 1977 return 0; 1978} 1979 1980static inline int security_binder_transfer_file(struct task_struct *from, 1981 struct task_struct *to, 1982 struct file *file) 1983{ 1984 return 0; 1985} 1986 1987static inline int security_ptrace_access_check(struct task_struct *child, 1988 unsigned int mode) 1989{ 1990 return cap_ptrace_access_check(child, mode); 1991} 1992 1993static inline int security_ptrace_traceme(struct task_struct *parent) 1994{ 1995 return cap_ptrace_traceme(parent); 1996} 1997 1998static inline int security_capget(struct task_struct *target, 1999 kernel_cap_t *effective, 2000 kernel_cap_t *inheritable, 2001 kernel_cap_t *permitted) 2002{ 2003 return cap_capget(target, effective, inheritable, permitted); 2004} 2005 2006static inline int security_capset(struct cred *new, 2007 const struct cred *old, 2008 const kernel_cap_t *effective, 2009 const kernel_cap_t *inheritable, 2010 const kernel_cap_t *permitted) 2011{ 2012 return cap_capset(new, old, effective, inheritable, permitted); 2013} 2014 2015static inline int security_capable(const struct cred *cred, 2016 struct user_namespace *ns, int cap) 2017{ 2018 return cap_capable(cred, ns, cap, SECURITY_CAP_AUDIT); 2019} 2020 2021static inline int security_capable_noaudit(const struct cred *cred, 2022 struct user_namespace *ns, int cap) { 2023 return cap_capable(cred, ns, cap, SECURITY_CAP_NOAUDIT); 2024} 2025 2026static inline int security_quotactl(int cmds, int type, int id, 2027 struct super_block *sb) 2028{ 2029 return 0; 2030} 2031 2032static inline int security_quota_on(struct dentry *dentry) 2033{ 2034 return 0; 2035} 2036 2037static inline int security_syslog(int type) 2038{ 2039 return 0; 2040} 2041 2042static inline int security_settime(const struct timespec *ts, 2043 const struct timezone *tz) 2044{ 2045 return cap_settime(ts, tz); 2046} 2047 2048static inline int security_vm_enough_memory_mm(struct mm_struct *mm, long pages) 2049{ 2050 return cap_vm_enough_memory(mm, pages); 2051} 2052 2053static inline int security_bprm_set_creds(struct linux_binprm *bprm) 2054{ 2055 return cap_bprm_set_creds(bprm); 2056} 2057 2058static inline int security_bprm_check(struct linux_binprm *bprm) 2059{ 2060 return 0; 2061} 2062 2063static inline void security_bprm_committing_creds(struct linux_binprm *bprm) 2064{ 2065} 2066 2067static inline void security_bprm_committed_creds(struct linux_binprm *bprm) 2068{ 2069} 2070 2071static inline int security_bprm_secureexec(struct linux_binprm *bprm) 2072{ 2073 return cap_bprm_secureexec(bprm); 2074} 2075 2076static inline int security_sb_alloc(struct super_block *sb) 2077{ 2078 return 0; 2079} 2080 2081static inline void security_sb_free(struct super_block *sb) 2082{ } 2083 2084static inline int security_sb_copy_data(char *orig, char *copy) 2085{ 2086 return 0; 2087} 2088 2089static inline int security_sb_remount(struct super_block *sb, void *data) 2090{ 2091 return 0; 2092} 2093 2094static inline int security_sb_kern_mount(struct super_block *sb, int flags, void *data) 2095{ 2096 return 0; 2097} 2098 2099static inline int security_sb_show_options(struct seq_file *m, 2100 struct super_block *sb) 2101{ 2102 return 0; 2103} 2104 2105static inline int security_sb_statfs(struct dentry *dentry) 2106{ 2107 return 0; 2108} 2109 2110static inline int security_sb_mount(const char *dev_name, struct path *path, 2111 const char *type, unsigned long flags, 2112 void *data) 2113{ 2114 return 0; 2115} 2116 2117static inline int security_sb_umount(struct vfsmount *mnt, int flags) 2118{ 2119 return 0; 2120} 2121 2122static inline int security_sb_pivotroot(struct path *old_path, 2123 struct path *new_path) 2124{ 2125 return 0; 2126} 2127 2128static inline int security_sb_set_mnt_opts(struct super_block *sb, 2129 struct security_mnt_opts *opts, 2130 unsigned long kern_flags, 2131 unsigned long *set_kern_flags) 2132{ 2133 return 0; 2134} 2135 2136static inline int security_sb_clone_mnt_opts(const struct super_block *oldsb, 2137 struct super_block *newsb) 2138{ 2139 return 0; 2140} 2141 2142static inline int security_sb_parse_opts_str(char *options, struct security_mnt_opts *opts) 2143{ 2144 return 0; 2145} 2146 2147static inline int security_inode_alloc(struct inode *inode) 2148{ 2149 return 0; 2150} 2151 2152static inline void security_inode_free(struct inode *inode) 2153{ } 2154 2155static inline int security_dentry_init_security(struct dentry *dentry, 2156 int mode, 2157 struct qstr *name, 2158 void **ctx, 2159 u32 *ctxlen) 2160{ 2161 return -EOPNOTSUPP; 2162} 2163 2164 2165static inline int security_inode_init_security(struct inode *inode, 2166 struct inode *dir, 2167 const struct qstr *qstr, 2168 const initxattrs xattrs, 2169 void *fs_data) 2170{ 2171 return 0; 2172} 2173 2174static inline int security_old_inode_init_security(struct inode *inode, 2175 struct inode *dir, 2176 const struct qstr *qstr, 2177 const char **name, 2178 void **value, size_t *len) 2179{ 2180 return -EOPNOTSUPP; 2181} 2182 2183static inline int security_inode_create(struct inode *dir, 2184 struct dentry *dentry, 2185 umode_t mode) 2186{ 2187 return 0; 2188} 2189 2190static inline int security_inode_link(struct dentry *old_dentry, 2191 struct inode *dir, 2192 struct dentry *new_dentry) 2193{ 2194 return 0; 2195} 2196 2197static inline int security_inode_unlink(struct inode *dir, 2198 struct dentry *dentry) 2199{ 2200 return 0; 2201} 2202 2203static inline int security_inode_symlink(struct inode *dir, 2204 struct dentry *dentry, 2205 const char *old_name) 2206{ 2207 return 0; 2208} 2209 2210static inline int security_inode_mkdir(struct inode *dir, 2211 struct dentry *dentry, 2212 int mode) 2213{ 2214 return 0; 2215} 2216 2217static inline int security_inode_rmdir(struct inode *dir, 2218 struct dentry *dentry) 2219{ 2220 return 0; 2221} 2222 2223static inline int security_inode_mknod(struct inode *dir, 2224 struct dentry *dentry, 2225 int mode, dev_t dev) 2226{ 2227 return 0; 2228} 2229 2230static inline int security_inode_rename(struct inode *old_dir, 2231 struct dentry *old_dentry, 2232 struct inode *new_dir, 2233 struct dentry *new_dentry, 2234 unsigned int flags) 2235{ 2236 return 0; 2237} 2238 2239static inline int security_inode_readlink(struct dentry *dentry) 2240{ 2241 return 0; 2242} 2243 2244static inline int security_inode_follow_link(struct dentry *dentry, 2245 struct nameidata *nd) 2246{ 2247 return 0; 2248} 2249 2250static inline int security_inode_permission(struct inode *inode, int mask) 2251{ 2252 return 0; 2253} 2254 2255static inline int security_inode_setattr(struct dentry *dentry, 2256 struct iattr *attr) 2257{ 2258 return 0; 2259} 2260 2261static inline int security_inode_getattr(const struct path *path) 2262{ 2263 return 0; 2264} 2265 2266static inline int security_inode_setxattr(struct dentry *dentry, 2267 const char *name, const void *value, size_t size, int flags) 2268{ 2269 return cap_inode_setxattr(dentry, name, value, size, flags); 2270} 2271 2272static inline void security_inode_post_setxattr(struct dentry *dentry, 2273 const char *name, const void *value, size_t size, int flags) 2274{ } 2275 2276static inline int security_inode_getxattr(struct dentry *dentry, 2277 const char *name) 2278{ 2279 return 0; 2280} 2281 2282static inline int security_inode_listxattr(struct dentry *dentry) 2283{ 2284 return 0; 2285} 2286 2287static inline int security_inode_removexattr(struct dentry *dentry, 2288 const char *name) 2289{ 2290 return cap_inode_removexattr(dentry, name); 2291} 2292 2293static inline int security_inode_need_killpriv(struct dentry *dentry) 2294{ 2295 return cap_inode_need_killpriv(dentry); 2296} 2297 2298static inline int security_inode_killpriv(struct dentry *dentry) 2299{ 2300 return cap_inode_killpriv(dentry); 2301} 2302 2303static inline int security_inode_getsecurity(const struct inode *inode, const char *name, void **buffer, bool alloc) 2304{ 2305 return -EOPNOTSUPP; 2306} 2307 2308static inline int security_inode_setsecurity(struct inode *inode, const char *name, const void *value, size_t size, int flags) 2309{ 2310 return -EOPNOTSUPP; 2311} 2312 2313static inline int security_inode_listsecurity(struct inode *inode, char *buffer, size_t buffer_size) 2314{ 2315 return 0; 2316} 2317 2318static inline void security_inode_getsecid(const struct inode *inode, u32 *secid) 2319{ 2320 *secid = 0; 2321} 2322 2323static inline int security_file_permission(struct file *file, int mask) 2324{ 2325 return 0; 2326} 2327 2328static inline int security_file_alloc(struct file *file) 2329{ 2330 return 0; 2331} 2332 2333static inline void security_file_free(struct file *file) 2334{ } 2335 2336static inline int security_file_ioctl(struct file *file, unsigned int cmd, 2337 unsigned long arg) 2338{ 2339 return 0; 2340} 2341 2342static inline int security_mmap_file(struct file *file, unsigned long prot, 2343 unsigned long flags) 2344{ 2345 return 0; 2346} 2347 2348static inline int security_mmap_addr(unsigned long addr) 2349{ 2350 return cap_mmap_addr(addr); 2351} 2352 2353static inline int security_file_mprotect(struct vm_area_struct *vma, 2354 unsigned long reqprot, 2355 unsigned long prot) 2356{ 2357 return 0; 2358} 2359 2360static inline int security_file_lock(struct file *file, unsigned int cmd) 2361{ 2362 return 0; 2363} 2364 2365static inline int security_file_fcntl(struct file *file, unsigned int cmd, 2366 unsigned long arg) 2367{ 2368 return 0; 2369} 2370 2371static inline void security_file_set_fowner(struct file *file) 2372{ 2373 return; 2374} 2375 2376static inline int security_file_send_sigiotask(struct task_struct *tsk, 2377 struct fown_struct *fown, 2378 int sig) 2379{ 2380 return 0; 2381} 2382 2383static inline int security_file_receive(struct file *file) 2384{ 2385 return 0; 2386} 2387 2388static inline int security_file_open(struct file *file, 2389 const struct cred *cred) 2390{ 2391 return 0; 2392} 2393 2394static inline int security_task_create(unsigned long clone_flags) 2395{ 2396 return 0; 2397} 2398 2399static inline void security_task_free(struct task_struct *task) 2400{ } 2401 2402static inline int security_cred_alloc_blank(struct cred *cred, gfp_t gfp) 2403{ 2404 return 0; 2405} 2406 2407static inline void security_cred_free(struct cred *cred) 2408{ } 2409 2410static inline int security_prepare_creds(struct cred *new, 2411 const struct cred *old, 2412 gfp_t gfp) 2413{ 2414 return 0; 2415} 2416 2417static inline void security_transfer_creds(struct cred *new, 2418 const struct cred *old) 2419{ 2420} 2421 2422static inline int security_kernel_act_as(struct cred *cred, u32 secid) 2423{ 2424 return 0; 2425} 2426 2427static inline int security_kernel_create_files_as(struct cred *cred, 2428 struct inode *inode) 2429{ 2430 return 0; 2431} 2432 2433static inline int security_kernel_fw_from_file(struct file *file, 2434 char *buf, size_t size) 2435{ 2436 return 0; 2437} 2438 2439static inline int security_kernel_module_request(char *kmod_name) 2440{ 2441 return 0; 2442} 2443 2444static inline int security_kernel_module_from_file(struct file *file) 2445{ 2446 return 0; 2447} 2448 2449static inline int security_task_fix_setuid(struct cred *new, 2450 const struct cred *old, 2451 int flags) 2452{ 2453 return cap_task_fix_setuid(new, old, flags); 2454} 2455 2456static inline int security_task_setpgid(struct task_struct *p, pid_t pgid) 2457{ 2458 return 0; 2459} 2460 2461static inline int security_task_getpgid(struct task_struct *p) 2462{ 2463 return 0; 2464} 2465 2466static inline int security_task_getsid(struct task_struct *p) 2467{ 2468 return 0; 2469} 2470 2471static inline void security_task_getsecid(struct task_struct *p, u32 *secid) 2472{ 2473 *secid = 0; 2474} 2475 2476static inline int security_task_setnice(struct task_struct *p, int nice) 2477{ 2478 return cap_task_setnice(p, nice); 2479} 2480 2481static inline int security_task_setioprio(struct task_struct *p, int ioprio) 2482{ 2483 return cap_task_setioprio(p, ioprio); 2484} 2485 2486static inline int security_task_getioprio(struct task_struct *p) 2487{ 2488 return 0; 2489} 2490 2491static inline int security_task_setrlimit(struct task_struct *p, 2492 unsigned int resource, 2493 struct rlimit *new_rlim) 2494{ 2495 return 0; 2496} 2497 2498static inline int security_task_setscheduler(struct task_struct *p) 2499{ 2500 return cap_task_setscheduler(p); 2501} 2502 2503static inline int security_task_getscheduler(struct task_struct *p) 2504{ 2505 return 0; 2506} 2507 2508static inline int security_task_movememory(struct task_struct *p) 2509{ 2510 return 0; 2511} 2512 2513static inline int security_task_kill(struct task_struct *p, 2514 struct siginfo *info, int sig, 2515 u32 secid) 2516{ 2517 return 0; 2518} 2519 2520static inline int security_task_wait(struct task_struct *p) 2521{ 2522 return 0; 2523} 2524 2525static inline int security_task_prctl(int option, unsigned long arg2, 2526 unsigned long arg3, 2527 unsigned long arg4, 2528 unsigned long arg5) 2529{ 2530 return cap_task_prctl(option, arg2, arg3, arg4, arg5); 2531} 2532 2533static inline void security_task_to_inode(struct task_struct *p, struct inode *inode) 2534{ } 2535 2536static inline int security_ipc_permission(struct kern_ipc_perm *ipcp, 2537 short flag) 2538{ 2539 return 0; 2540} 2541 2542static inline void security_ipc_getsecid(struct kern_ipc_perm *ipcp, u32 *secid) 2543{ 2544 *secid = 0; 2545} 2546 2547static inline int security_msg_msg_alloc(struct msg_msg *msg) 2548{ 2549 return 0; 2550} 2551 2552static inline void security_msg_msg_free(struct msg_msg *msg) 2553{ } 2554 2555static inline int security_msg_queue_alloc(struct msg_queue *msq) 2556{ 2557 return 0; 2558} 2559 2560static inline void security_msg_queue_free(struct msg_queue *msq) 2561{ } 2562 2563static inline int security_msg_queue_associate(struct msg_queue *msq, 2564 int msqflg) 2565{ 2566 return 0; 2567} 2568 2569static inline int security_msg_queue_msgctl(struct msg_queue *msq, int cmd) 2570{ 2571 return 0; 2572} 2573 2574static inline int security_msg_queue_msgsnd(struct msg_queue *msq, 2575 struct msg_msg *msg, int msqflg) 2576{ 2577 return 0; 2578} 2579 2580static inline int security_msg_queue_msgrcv(struct msg_queue *msq, 2581 struct msg_msg *msg, 2582 struct task_struct *target, 2583 long type, int mode) 2584{ 2585 return 0; 2586} 2587 2588static inline int security_shm_alloc(struct shmid_kernel *shp) 2589{ 2590 return 0; 2591} 2592 2593static inline void security_shm_free(struct shmid_kernel *shp) 2594{ } 2595 2596static inline int security_shm_associate(struct shmid_kernel *shp, 2597 int shmflg) 2598{ 2599 return 0; 2600} 2601 2602static inline int security_shm_shmctl(struct shmid_kernel *shp, int cmd) 2603{ 2604 return 0; 2605} 2606 2607static inline int security_shm_shmat(struct shmid_kernel *shp, 2608 char __user *shmaddr, int shmflg) 2609{ 2610 return 0; 2611} 2612 2613static inline int security_sem_alloc(struct sem_array *sma) 2614{ 2615 return 0; 2616} 2617 2618static inline void security_sem_free(struct sem_array *sma) 2619{ } 2620 2621static inline int security_sem_associate(struct sem_array *sma, int semflg) 2622{ 2623 return 0; 2624} 2625 2626static inline int security_sem_semctl(struct sem_array *sma, int cmd) 2627{ 2628 return 0; 2629} 2630 2631static inline int security_sem_semop(struct sem_array *sma, 2632 struct sembuf *sops, unsigned nsops, 2633 int alter) 2634{ 2635 return 0; 2636} 2637 2638static inline void security_d_instantiate(struct dentry *dentry, struct inode *inode) 2639{ } 2640 2641static inline int security_getprocattr(struct task_struct *p, char *name, char **value) 2642{ 2643 return -EINVAL; 2644} 2645 2646static inline int security_setprocattr(struct task_struct *p, char *name, void *value, size_t size) 2647{ 2648 return -EINVAL; 2649} 2650 2651static inline int security_netlink_send(struct sock *sk, struct sk_buff *skb) 2652{ 2653 return cap_netlink_send(sk, skb); 2654} 2655 2656static inline int security_ismaclabel(const char *name) 2657{ 2658 return 0; 2659} 2660 2661static inline int security_secid_to_secctx(u32 secid, char **secdata, u32 *seclen) 2662{ 2663 return -EOPNOTSUPP; 2664} 2665 2666static inline int security_secctx_to_secid(const char *secdata, 2667 u32 seclen, 2668 u32 *secid) 2669{ 2670 return -EOPNOTSUPP; 2671} 2672 2673static inline void security_release_secctx(char *secdata, u32 seclen) 2674{ 2675} 2676 2677static inline int security_inode_notifysecctx(struct inode *inode, void *ctx, u32 ctxlen) 2678{ 2679 return -EOPNOTSUPP; 2680} 2681static inline int security_inode_setsecctx(struct dentry *dentry, void *ctx, u32 ctxlen) 2682{ 2683 return -EOPNOTSUPP; 2684} 2685static inline int security_inode_getsecctx(struct inode *inode, void **ctx, u32 *ctxlen) 2686{ 2687 return -EOPNOTSUPP; 2688} 2689#endif /* CONFIG_SECURITY */ 2690 2691#ifdef CONFIG_SECURITY_NETWORK 2692 2693int security_unix_stream_connect(struct sock *sock, struct sock *other, struct sock *newsk); 2694int security_unix_may_send(struct socket *sock, struct socket *other); 2695int security_socket_create(int family, int type, int protocol, int kern); 2696int security_socket_post_create(struct socket *sock, int family, 2697 int type, int protocol, int kern); 2698int security_socket_bind(struct socket *sock, struct sockaddr *address, int addrlen); 2699int security_socket_connect(struct socket *sock, struct sockaddr *address, int addrlen); 2700int security_socket_listen(struct socket *sock, int backlog); 2701int security_socket_accept(struct socket *sock, struct socket *newsock); 2702int security_socket_sendmsg(struct socket *sock, struct msghdr *msg, int size); 2703int security_socket_recvmsg(struct socket *sock, struct msghdr *msg, 2704 int size, int flags); 2705int security_socket_getsockname(struct socket *sock); 2706int security_socket_getpeername(struct socket *sock); 2707int security_socket_getsockopt(struct socket *sock, int level, int optname); 2708int security_socket_setsockopt(struct socket *sock, int level, int optname); 2709int security_socket_shutdown(struct socket *sock, int how); 2710int security_sock_rcv_skb(struct sock *sk, struct sk_buff *skb); 2711int security_socket_getpeersec_stream(struct socket *sock, char __user *optval, 2712 int __user *optlen, unsigned len); 2713int security_socket_getpeersec_dgram(struct socket *sock, struct sk_buff *skb, u32 *secid); 2714int security_sk_alloc(struct sock *sk, int family, gfp_t priority); 2715void security_sk_free(struct sock *sk); 2716void security_sk_clone(const struct sock *sk, struct sock *newsk); 2717void security_sk_classify_flow(struct sock *sk, struct flowi *fl); 2718void security_req_classify_flow(const struct request_sock *req, struct flowi *fl); 2719void security_sock_graft(struct sock*sk, struct socket *parent); 2720int security_inet_conn_request(struct sock *sk, 2721 struct sk_buff *skb, struct request_sock *req); 2722void security_inet_csk_clone(struct sock *newsk, 2723 const struct request_sock *req); 2724void security_inet_conn_established(struct sock *sk, 2725 struct sk_buff *skb); 2726int security_secmark_relabel_packet(u32 secid); 2727void security_secmark_refcount_inc(void); 2728void security_secmark_refcount_dec(void); 2729int security_tun_dev_alloc_security(void **security); 2730void security_tun_dev_free_security(void *security); 2731int security_tun_dev_create(void); 2732int security_tun_dev_attach_queue(void *security); 2733int security_tun_dev_attach(struct sock *sk, void *security); 2734int security_tun_dev_open(void *security); 2735 2736#else /* CONFIG_SECURITY_NETWORK */ 2737static inline int security_unix_stream_connect(struct sock *sock, 2738 struct sock *other, 2739 struct sock *newsk) 2740{ 2741 return 0; 2742} 2743 2744static inline int security_unix_may_send(struct socket *sock, 2745 struct socket *other) 2746{ 2747 return 0; 2748} 2749 2750static inline int security_socket_create(int family, int type, 2751 int protocol, int kern) 2752{ 2753 return 0; 2754} 2755 2756static inline int security_socket_post_create(struct socket *sock, 2757 int family, 2758 int type, 2759 int protocol, int kern) 2760{ 2761 return 0; 2762} 2763 2764static inline int security_socket_bind(struct socket *sock, 2765 struct sockaddr *address, 2766 int addrlen) 2767{ 2768 return 0; 2769} 2770 2771static inline int security_socket_connect(struct socket *sock, 2772 struct sockaddr *address, 2773 int addrlen) 2774{ 2775 return 0; 2776} 2777 2778static inline int security_socket_listen(struct socket *sock, int backlog) 2779{ 2780 return 0; 2781} 2782 2783static inline int security_socket_accept(struct socket *sock, 2784 struct socket *newsock) 2785{ 2786 return 0; 2787} 2788 2789static inline int security_socket_sendmsg(struct socket *sock, 2790 struct msghdr *msg, int size) 2791{ 2792 return 0; 2793} 2794 2795static inline int security_socket_recvmsg(struct socket *sock, 2796 struct msghdr *msg, int size, 2797 int flags) 2798{ 2799 return 0; 2800} 2801 2802static inline int security_socket_getsockname(struct socket *sock) 2803{ 2804 return 0; 2805} 2806 2807static inline int security_socket_getpeername(struct socket *sock) 2808{ 2809 return 0; 2810} 2811 2812static inline int security_socket_getsockopt(struct socket *sock, 2813 int level, int optname) 2814{ 2815 return 0; 2816} 2817 2818static inline int security_socket_setsockopt(struct socket *sock, 2819 int level, int optname) 2820{ 2821 return 0; 2822} 2823 2824static inline int security_socket_shutdown(struct socket *sock, int how) 2825{ 2826 return 0; 2827} 2828static inline int security_sock_rcv_skb(struct sock *sk, 2829 struct sk_buff *skb) 2830{ 2831 return 0; 2832} 2833 2834static inline int security_socket_getpeersec_stream(struct socket *sock, char __user *optval, 2835 int __user *optlen, unsigned len) 2836{ 2837 return -ENOPROTOOPT; 2838} 2839 2840static inline int security_socket_getpeersec_dgram(struct socket *sock, struct sk_buff *skb, u32 *secid) 2841{ 2842 return -ENOPROTOOPT; 2843} 2844 2845static inline int security_sk_alloc(struct sock *sk, int family, gfp_t priority) 2846{ 2847 return 0; 2848} 2849 2850static inline void security_sk_free(struct sock *sk) 2851{ 2852} 2853 2854static inline void security_sk_clone(const struct sock *sk, struct sock *newsk) 2855{ 2856} 2857 2858static inline void security_sk_classify_flow(struct sock *sk, struct flowi *fl) 2859{ 2860} 2861 2862static inline void security_req_classify_flow(const struct request_sock *req, struct flowi *fl) 2863{ 2864} 2865 2866static inline void security_sock_graft(struct sock *sk, struct socket *parent) 2867{ 2868} 2869 2870static inline int security_inet_conn_request(struct sock *sk, 2871 struct sk_buff *skb, struct request_sock *req) 2872{ 2873 return 0; 2874} 2875 2876static inline void security_inet_csk_clone(struct sock *newsk, 2877 const struct request_sock *req) 2878{ 2879} 2880 2881static inline void security_inet_conn_established(struct sock *sk, 2882 struct sk_buff *skb) 2883{ 2884} 2885 2886static inline int security_secmark_relabel_packet(u32 secid) 2887{ 2888 return 0; 2889} 2890 2891static inline void security_secmark_refcount_inc(void) 2892{ 2893} 2894 2895static inline void security_secmark_refcount_dec(void) 2896{ 2897} 2898 2899static inline int security_tun_dev_alloc_security(void **security) 2900{ 2901 return 0; 2902} 2903 2904static inline void security_tun_dev_free_security(void *security) 2905{ 2906} 2907 2908static inline int security_tun_dev_create(void) 2909{ 2910 return 0; 2911} 2912 2913static inline int security_tun_dev_attach_queue(void *security) 2914{ 2915 return 0; 2916} 2917 2918static inline int security_tun_dev_attach(struct sock *sk, void *security) 2919{ 2920 return 0; 2921} 2922 2923static inline int security_tun_dev_open(void *security) 2924{ 2925 return 0; 2926} 2927#endif /* CONFIG_SECURITY_NETWORK */ 2928 2929#ifdef CONFIG_SECURITY_NETWORK_XFRM 2930 2931int security_xfrm_policy_alloc(struct xfrm_sec_ctx **ctxp, 2932 struct xfrm_user_sec_ctx *sec_ctx, gfp_t gfp); 2933int security_xfrm_policy_clone(struct xfrm_sec_ctx *old_ctx, struct xfrm_sec_ctx **new_ctxp); 2934void security_xfrm_policy_free(struct xfrm_sec_ctx *ctx); 2935int security_xfrm_policy_delete(struct xfrm_sec_ctx *ctx); 2936int security_xfrm_state_alloc(struct xfrm_state *x, struct xfrm_user_sec_ctx *sec_ctx); 2937int security_xfrm_state_alloc_acquire(struct xfrm_state *x, 2938 struct xfrm_sec_ctx *polsec, u32 secid); 2939int security_xfrm_state_delete(struct xfrm_state *x); 2940void security_xfrm_state_free(struct xfrm_state *x); 2941int security_xfrm_policy_lookup(struct xfrm_sec_ctx *ctx, u32 fl_secid, u8 dir); 2942int security_xfrm_state_pol_flow_match(struct xfrm_state *x, 2943 struct xfrm_policy *xp, 2944 const struct flowi *fl); 2945int security_xfrm_decode_session(struct sk_buff *skb, u32 *secid); 2946void security_skb_classify_flow(struct sk_buff *skb, struct flowi *fl); 2947 2948#else /* CONFIG_SECURITY_NETWORK_XFRM */ 2949 2950static inline int security_xfrm_policy_alloc(struct xfrm_sec_ctx **ctxp, 2951 struct xfrm_user_sec_ctx *sec_ctx, 2952 gfp_t gfp) 2953{ 2954 return 0; 2955} 2956 2957static inline int security_xfrm_policy_clone(struct xfrm_sec_ctx *old, struct xfrm_sec_ctx **new_ctxp) 2958{ 2959 return 0; 2960} 2961 2962static inline void security_xfrm_policy_free(struct xfrm_sec_ctx *ctx) 2963{ 2964} 2965 2966static inline int security_xfrm_policy_delete(struct xfrm_sec_ctx *ctx) 2967{ 2968 return 0; 2969} 2970 2971static inline int security_xfrm_state_alloc(struct xfrm_state *x, 2972 struct xfrm_user_sec_ctx *sec_ctx) 2973{ 2974 return 0; 2975} 2976 2977static inline int security_xfrm_state_alloc_acquire(struct xfrm_state *x, 2978 struct xfrm_sec_ctx *polsec, u32 secid) 2979{ 2980 return 0; 2981} 2982 2983static inline void security_xfrm_state_free(struct xfrm_state *x) 2984{ 2985} 2986 2987static inline int security_xfrm_state_delete(struct xfrm_state *x) 2988{ 2989 return 0; 2990} 2991 2992static inline int security_xfrm_policy_lookup(struct xfrm_sec_ctx *ctx, u32 fl_secid, u8 dir) 2993{ 2994 return 0; 2995} 2996 2997static inline int security_xfrm_state_pol_flow_match(struct xfrm_state *x, 2998 struct xfrm_policy *xp, const struct flowi *fl) 2999{ 3000 return 1; 3001} 3002 3003static inline int security_xfrm_decode_session(struct sk_buff *skb, u32 *secid) 3004{ 3005 return 0; 3006} 3007 3008static inline void security_skb_classify_flow(struct sk_buff *skb, struct flowi *fl) 3009{ 3010} 3011 3012#endif /* CONFIG_SECURITY_NETWORK_XFRM */ 3013 3014#ifdef CONFIG_SECURITY_PATH 3015int security_path_unlink(struct path *dir, struct dentry *dentry); 3016int security_path_mkdir(struct path *dir, struct dentry *dentry, umode_t mode); 3017int security_path_rmdir(struct path *dir, struct dentry *dentry); 3018int security_path_mknod(struct path *dir, struct dentry *dentry, umode_t mode, 3019 unsigned int dev); 3020int security_path_truncate(struct path *path); 3021int security_path_symlink(struct path *dir, struct dentry *dentry, 3022 const char *old_name); 3023int security_path_link(struct dentry *old_dentry, struct path *new_dir, 3024 struct dentry *new_dentry); 3025int security_path_rename(struct path *old_dir, struct dentry *old_dentry, 3026 struct path *new_dir, struct dentry *new_dentry, 3027 unsigned int flags); 3028int security_path_chmod(struct path *path, umode_t mode); 3029int security_path_chown(struct path *path, kuid_t uid, kgid_t gid); 3030int security_path_chroot(struct path *path); 3031#else /* CONFIG_SECURITY_PATH */ 3032static inline int security_path_unlink(struct path *dir, struct dentry *dentry) 3033{ 3034 return 0; 3035} 3036 3037static inline int security_path_mkdir(struct path *dir, struct dentry *dentry, 3038 umode_t mode) 3039{ 3040 return 0; 3041} 3042 3043static inline int security_path_rmdir(struct path *dir, struct dentry *dentry) 3044{ 3045 return 0; 3046} 3047 3048static inline int security_path_mknod(struct path *dir, struct dentry *dentry, 3049 umode_t mode, unsigned int dev) 3050{ 3051 return 0; 3052} 3053 3054static inline int security_path_truncate(struct path *path) 3055{ 3056 return 0; 3057} 3058 3059static inline int security_path_symlink(struct path *dir, struct dentry *dentry, 3060 const char *old_name) 3061{ 3062 return 0; 3063} 3064 3065static inline int security_path_link(struct dentry *old_dentry, 3066 struct path *new_dir, 3067 struct dentry *new_dentry) 3068{ 3069 return 0; 3070} 3071 3072static inline int security_path_rename(struct path *old_dir, 3073 struct dentry *old_dentry, 3074 struct path *new_dir, 3075 struct dentry *new_dentry, 3076 unsigned int flags) 3077{ 3078 return 0; 3079} 3080 3081static inline int security_path_chmod(struct path *path, umode_t mode) 3082{ 3083 return 0; 3084} 3085 3086static inline int security_path_chown(struct path *path, kuid_t uid, kgid_t gid) 3087{ 3088 return 0; 3089} 3090 3091static inline int security_path_chroot(struct path *path) 3092{ 3093 return 0; 3094} 3095#endif /* CONFIG_SECURITY_PATH */ 3096 3097#ifdef CONFIG_KEYS 3098#ifdef CONFIG_SECURITY 3099 3100int security_key_alloc(struct key *key, const struct cred *cred, unsigned long flags); 3101void security_key_free(struct key *key); 3102int security_key_permission(key_ref_t key_ref, 3103 const struct cred *cred, unsigned perm); 3104int security_key_getsecurity(struct key *key, char **_buffer); 3105 3106#else 3107 3108static inline int security_key_alloc(struct key *key, 3109 const struct cred *cred, 3110 unsigned long flags) 3111{ 3112 return 0; 3113} 3114 3115static inline void security_key_free(struct key *key) 3116{ 3117} 3118 3119static inline int security_key_permission(key_ref_t key_ref, 3120 const struct cred *cred, 3121 unsigned perm) 3122{ 3123 return 0; 3124} 3125 3126static inline int security_key_getsecurity(struct key *key, char **_buffer) 3127{ 3128 *_buffer = NULL; 3129 return 0; 3130} 3131 3132#endif 3133#endif /* CONFIG_KEYS */ 3134 3135#ifdef CONFIG_AUDIT 3136#ifdef CONFIG_SECURITY 3137int security_audit_rule_init(u32 field, u32 op, char *rulestr, void **lsmrule); 3138int security_audit_rule_known(struct audit_krule *krule); 3139int security_audit_rule_match(u32 secid, u32 field, u32 op, void *lsmrule, 3140 struct audit_context *actx); 3141void security_audit_rule_free(void *lsmrule); 3142 3143#else 3144 3145static inline int security_audit_rule_init(u32 field, u32 op, char *rulestr, 3146 void **lsmrule) 3147{ 3148 return 0; 3149} 3150 3151static inline int security_audit_rule_known(struct audit_krule *krule) 3152{ 3153 return 0; 3154} 3155 3156static inline int security_audit_rule_match(u32 secid, u32 field, u32 op, 3157 void *lsmrule, struct audit_context *actx) 3158{ 3159 return 0; 3160} 3161 3162static inline void security_audit_rule_free(void *lsmrule) 3163{ } 3164 3165#endif /* CONFIG_SECURITY */ 3166#endif /* CONFIG_AUDIT */ 3167 3168#ifdef CONFIG_SECURITYFS 3169 3170extern struct dentry *securityfs_create_file(const char *name, umode_t mode, 3171 struct dentry *parent, void *data, 3172 const struct file_operations *fops); 3173extern struct dentry *securityfs_create_dir(const char *name, struct dentry *parent); 3174extern void securityfs_remove(struct dentry *dentry); 3175 3176#else /* CONFIG_SECURITYFS */ 3177 3178static inline struct dentry *securityfs_create_dir(const char *name, 3179 struct dentry *parent) 3180{ 3181 return ERR_PTR(-ENODEV); 3182} 3183 3184static inline struct dentry *securityfs_create_file(const char *name, 3185 umode_t mode, 3186 struct dentry *parent, 3187 void *data, 3188 const struct file_operations *fops) 3189{ 3190 return ERR_PTR(-ENODEV); 3191} 3192 3193static inline void securityfs_remove(struct dentry *dentry) 3194{} 3195 3196#endif 3197 3198#ifdef CONFIG_SECURITY 3199 3200static inline char *alloc_secdata(void) 3201{ 3202 return (char *)get_zeroed_page(GFP_KERNEL); 3203} 3204 3205static inline void free_secdata(void *secdata) 3206{ 3207 free_page((unsigned long)secdata); 3208} 3209 3210#else 3211 3212static inline char *alloc_secdata(void) 3213{ 3214 return (char *)1; 3215} 3216 3217static inline void free_secdata(void *secdata) 3218{ } 3219#endif /* CONFIG_SECURITY */ 3220 3221#ifdef CONFIG_SECURITY_YAMA 3222extern int yama_ptrace_access_check(struct task_struct *child, 3223 unsigned int mode); 3224extern int yama_ptrace_traceme(struct task_struct *parent); 3225extern void yama_task_free(struct task_struct *task); 3226extern int yama_task_prctl(int option, unsigned long arg2, unsigned long arg3, 3227 unsigned long arg4, unsigned long arg5); 3228#else 3229static inline int yama_ptrace_access_check(struct task_struct *child, 3230 unsigned int mode) 3231{ 3232 return 0; 3233} 3234 3235static inline int yama_ptrace_traceme(struct task_struct *parent) 3236{ 3237 return 0; 3238} 3239 3240static inline void yama_task_free(struct task_struct *task) 3241{ 3242} 3243 3244static inline int yama_task_prctl(int option, unsigned long arg2, 3245 unsigned long arg3, unsigned long arg4, 3246 unsigned long arg5) 3247{ 3248 return -ENOSYS; 3249} 3250#endif /* CONFIG_SECURITY_YAMA */ 3251 3252#endif /* ! __LINUX_SECURITY_H */ 3253 3254