security/dummy.c

   1 /*
   2  * Stub functions for the default security function pointers in case no
   3  * security model is loaded.
   4  *
   5  * Copyright (C) 2001 WireX Communications, Inc <chris@wirex.com>
   6  * Copyright (C) 2001-2002  Greg Kroah-Hartman <greg@kroah.com>
   7  * Copyright (C) 2001 Networks Associates Technology, Inc <ssmalley@nai.com>
   8  *
   9  *      This program is free software; you can redistribute it and/or modify
  10  *      it under the terms of the GNU General Public License as published by
  11  *      the Free Software Foundation; either version 2 of the License, or
  12  *      (at your option) any later version.
  13  */
  14
  15 #undef DEBUG
  16
  17 #include <linux/config.h>
  18 #include <linux/module.h>
  19 #include <linux/kernel.h>
  20 #include <linux/security.h>
  21 #include <linux/skbuff.h>
  22 #include <linux/netlink.h>
  23 #include <net/sock.h>
  24
  25 static int dummy_ptrace (struct task_struct *parent, struct task_struct *child)
  26 {
  27         return 0;
  28 }
  29
  30 static int dummy_capget (struct task_struct *target, kernel_cap_t * effective,
  31                          kernel_cap_t * inheritable, kernel_cap_t * permitted)
  32 {
  33         *effective = *inheritable = *permitted = 0;
  34         if (!issecure(SECURE_NOROOT)) {
  35                 if (target->euid == 0) {
  36                         *permitted |= (~0 & ~CAP_FS_MASK);
  37                         *effective |= (~0 & ~CAP_TO_MASK(CAP_SETPCAP) & ~CAP_FS_MASK);
  38                 }
  39                 if (target->fsuid == 0) {
  40                         *permitted |= CAP_FS_MASK;
  41                         *effective |= CAP_FS_MASK;
  42                 }
  43         }
  44         return 0;
  45 }
  46
  47 static int dummy_capset_check (struct task_struct *target,
  48                                kernel_cap_t * effective,
  49                                kernel_cap_t * inheritable,
  50                                kernel_cap_t * permitted)
  51 {
  52         return -EPERM;
  53 }
  54
  55 static void dummy_capset_set (struct task_struct *target,
  56                               kernel_cap_t * effective,
  57                               kernel_cap_t * inheritable,
  58                               kernel_cap_t * permitted)
  59 {
  60         return;
  61 }
  62
  63 static int dummy_acct (struct file *file)
  64 {
  65         return 0;
  66 }
  67
  68 static int dummy_capable (struct task_struct *tsk, int cap)
  69 {
  70         if (cap_is_fs_cap (cap) ? tsk->fsuid == 0 : tsk->euid == 0)
  71                 /* capability granted */
  72                 return 0;
  73
  74         /* capability denied */
  75         return -EPERM;
  76 }
  77
  78 static int dummy_sysctl (ctl_table * table, int op)
  79 {
  80         return 0;
  81 }
  82
  83 static int dummy_quotactl (int cmds, int type, int id, struct super_block *sb)
  84 {
  85         return 0;
  86 }
  87
  88 static int dummy_quota_on (struct file *f)
  89 {
  90         return 0;
  91 }
  92
  93 static int dummy_syslog (int type)
  94 {
  95         if ((type != 3) && current->euid)
  96                 return -EPERM;
  97         return 0;
  98 }
  99
 100 static int dummy_bprm_alloc_security (struct linux_binprm *bprm)
 101 {
 102         return 0;
 103 }
 104
 105 static void dummy_bprm_free_security (struct linux_binprm *bprm)
 106 {
 107         return;
 108 }
 109
 110 static void dummy_bprm_compute_creds (struct linux_binprm *bprm)
 111 {
 112         return;
 113 }
 114
 115 static int dummy_bprm_set_security (struct linux_binprm *bprm)
 116 {
 117         return 0;
 118 }
 119
 120 static int dummy_bprm_check_security (struct linux_binprm *bprm)
 121 {
 122         return 0;
 123 }
 124
 125 static int dummy_sb_alloc_security (struct super_block *sb)
 126 {
 127         return 0;
 128 }
 129
 130 static void dummy_sb_free_security (struct super_block *sb)
 131 {
 132         return;
 133 }
 134
 135 static int dummy_sb_kern_mount (struct super_block *sb)
 136 {
 137         return 0;
 138 }
 139
 140 static int dummy_sb_statfs (struct super_block *sb)
 141 {
 142         return 0;
 143 }
 144
 145 static int dummy_sb_mount (char *dev_name, struct nameidata *nd, char *type,
 146                            unsigned long flags, void *data)
 147 {
 148         return 0;
 149 }
 150
 151 static int dummy_sb_check_sb (struct vfsmount *mnt, struct nameidata *nd)
 152 {
 153         return 0;
 154 }
 155
 156 static int dummy_sb_umount (struct vfsmount *mnt, int flags)
 157 {
 158         return 0;
 159 }
 160
 161 static void dummy_sb_umount_close (struct vfsmount *mnt)
 162 {
 163         return;
 164 }
 165
 166 static void dummy_sb_umount_busy (struct vfsmount *mnt)
 167 {
 168         return;
 169 }
 170
 171 static void dummy_sb_post_remount (struct vfsmount *mnt, unsigned long flags,
 172                                    void *data)
 173 {
 174         return;
 175 }
 176
 177
 178 static void dummy_sb_post_mountroot (void)
 179 {
 180         return;
 181 }
 182
 183 static void dummy_sb_post_addmount (struct vfsmount *mnt, struct nameidata *nd)
 184 {
 185         return;
 186 }
 187
 188 static int dummy_sb_pivotroot (struct nameidata *old_nd, struct nameidata *new_nd)
 189 {
 190         return 0;
 191 }
 192
 193 static void dummy_sb_post_pivotroot (struct nameidata *old_nd, struct nameidata *new_nd)
 194 {
 195         return;
 196 }
 197
 198 static int dummy_inode_alloc_security (struct inode *inode)
 199 {
 200         return 0;
 201 }
 202
 203 static void dummy_inode_free_security (struct inode *inode)
 204 {
 205         return;
 206 }
 207
 208 static int dummy_inode_create (struct inode *inode, struct dentry *dentry,
 209                                int mask)
 210 {
 211         return 0;
 212 }
 213
 214 static void dummy_inode_post_create (struct inode *inode, struct dentry *dentry,
 215                                      int mask)
 216 {
 217         return;
 218 }
 219
 220 static int dummy_inode_link (struct dentry *old_dentry, struct inode *inode,
 221                              struct dentry *new_dentry)
 222 {
 223         return 0;
 224 }
 225
 226 static void dummy_inode_post_link (struct dentry *old_dentry,
 227                                    struct inode *inode,
 228                                    struct dentry *new_dentry)
 229 {
 230         return;
 231 }
 232
 233 static int dummy_inode_unlink (struct inode *inode, struct dentry *dentry)
 234 {
 235         return 0;
 236 }
 237
 238 static int dummy_inode_symlink (struct inode *inode, struct dentry *dentry,
 239                                 const char *name)
 240 {
 241         return 0;
 242 }
 243
 244 static void dummy_inode_post_symlink (struct inode *inode,
 245                                       struct dentry *dentry, const char *name)
 246 {
 247         return;
 248 }
 249
 250 static int dummy_inode_mkdir (struct inode *inode, struct dentry *dentry,
 251                               int mask)
 252 {
 253         return 0;
 254 }
 255
 256 static void dummy_inode_post_mkdir (struct inode *inode, struct dentry *dentry,
 257                                     int mask)
 258 {
 259         return;
 260 }
 261
 262 static int dummy_inode_rmdir (struct inode *inode, struct dentry *dentry)
 263 {
 264         return 0;
 265 }
 266
 267 static int dummy_inode_mknod (struct inode *inode, struct dentry *dentry,
 268                               int mode, dev_t dev)
 269 {
 270         return 0;
 271 }
 272
 273 static void dummy_inode_post_mknod (struct inode *inode, struct dentry *dentry,
 274                                     int mode, dev_t dev)
 275 {
 276         return;
 277 }
 278
 279 static int dummy_inode_rename (struct inode *old_inode,
 280                                struct dentry *old_dentry,
 281                                struct inode *new_inode,
 282                                struct dentry *new_dentry)
 283 {
 284         return 0;
 285 }
 286
 287 static void dummy_inode_post_rename (struct inode *old_inode,
 288                                      struct dentry *old_dentry,
 289                                      struct inode *new_inode,
 290                                      struct dentry *new_dentry)
 291 {
 292         return;
 293 }
 294
 295 static int dummy_inode_readlink (struct dentry *dentry)
 296 {
 297         return 0;
 298 }
 299
 300 static int dummy_inode_follow_link (struct dentry *dentry,
 301                                     struct nameidata *nameidata)
 302 {
 303         return 0;
 304 }
 305
 306 static int dummy_inode_permission (struct inode *inode, int mask)
 307 {
 308         return 0;
 309 }
 310
 311 static int dummy_inode_setattr (struct dentry *dentry, struct iattr *iattr)
 312 {
 313         return 0;
 314 }
 315
 316 static int dummy_inode_getattr (struct vfsmount *mnt, struct dentry *dentry)
 317 {
 318         return 0;
 319 }
 320
 321 static void dummy_inode_delete (struct inode *ino)
 322 {
 323         return;
 324 }
 325
 326 static int dummy_inode_setxattr (struct dentry *dentry, char *name, void *value,
 327                                 size_t size, int flags)
 328 {
 329         return 0;
 330 }
 331
 332 static void dummy_inode_post_setxattr (struct dentry *dentry, char *name, void *value,
 333                                        size_t size, int flags)
 334 {
 335 }
 336
 337 static int dummy_inode_getxattr (struct dentry *dentry, char *name)
 338 {
 339         return 0;
 340 }
 341
 342 static int dummy_inode_listxattr (struct dentry *dentry)
 343 {
 344         return 0;
 345 }
 346
 347 static int dummy_inode_removexattr (struct dentry *dentry, char *name)
 348 {
 349         return 0;
 350 }
 351
 352 static int dummy_inode_getsecurity(struct dentry *dentry, const char *name, void *buffer, size_t size)
 353 {
 354         return -EOPNOTSUPP;
 355 }
 356
 357 static int dummy_inode_setsecurity(struct dentry *dentry, const char *name, const void *value, size_t size, int flags)
 358 {
 359         return -EOPNOTSUPP;
 360 }
 361
 362 static int dummy_inode_listsecurity(struct dentry *dentry, char *buffer)
 363 {
 364         return 0;
 365 }
 366
 367 static int dummy_file_permission (struct file *file, int mask)
 368 {
 369         return 0;
 370 }
 371
 372 static int dummy_file_alloc_security (struct file *file)
 373 {
 374         return 0;
 375 }
 376
 377 static void dummy_file_free_security (struct file *file)
 378 {
 379         return;
 380 }
 381
 382 static int dummy_file_ioctl (struct file *file, unsigned int command,
 383                              unsigned long arg)
 384 {
 385         return 0;
 386 }
 387
 388 static int dummy_file_mmap (struct file *file, unsigned long prot,
 389                             unsigned long flags)
 390 {
 391         return 0;
 392 }
 393
 394 static int dummy_file_mprotect (struct vm_area_struct *vma, unsigned long prot)
 395 {
 396         return 0;
 397 }
 398
 399 static int dummy_file_lock (struct file *file, unsigned int cmd)
 400 {
 401         return 0;
 402 }
 403
 404 static int dummy_file_fcntl (struct file *file, unsigned int cmd,
 405                              unsigned long arg)
 406 {
 407         return 0;
 408 }
 409
 410 static int dummy_file_set_fowner (struct file *file)
 411 {
 412         return 0;
 413 }
 414
 415 static int dummy_file_send_sigiotask (struct task_struct *tsk,
 416                                       struct fown_struct *fown, int fd,
 417                                       int reason)
 418 {
 419         return 0;
 420 }
 421
 422 static int dummy_file_receive (struct file *file)
 423 {
 424         return 0;
 425 }
 426
 427 static int dummy_task_create (unsigned long clone_flags)
 428 {
 429         return 0;
 430 }
 431
 432 static int dummy_task_alloc_security (struct task_struct *p)
 433 {
 434         return 0;
 435 }
 436
 437 static void dummy_task_free_security (struct task_struct *p)
 438 {
 439         return;
 440 }
 441
 442 static int dummy_task_setuid (uid_t id0, uid_t id1, uid_t id2, int flags)
 443 {
 444         return 0;
 445 }
 446
 447 static int dummy_task_post_setuid (uid_t id0, uid_t id1, uid_t id2, int flags)
 448 {
 449         return 0;
 450 }
 451
 452 static int dummy_task_setgid (gid_t id0, gid_t id1, gid_t id2, int flags)
 453 {
 454         return 0;
 455 }
 456
 457 static int dummy_task_setpgid (struct task_struct *p, pid_t pgid)
 458 {
 459         return 0;
 460 }
 461
 462 static int dummy_task_getpgid (struct task_struct *p)
 463 {
 464         return 0;
 465 }
 466
 467 static int dummy_task_getsid (struct task_struct *p)
 468 {
 469         return 0;
 470 }
 471
 472 static int dummy_task_setgroups (int gidsetsize, gid_t * grouplist)
 473 {
 474         return 0;
 475 }
 476
 477 static int dummy_task_setnice (struct task_struct *p, int nice)
 478 {
 479         return 0;
 480 }
 481
 482 static int dummy_task_setrlimit (unsigned int resource, struct rlimit *new_rlim)
 483 {
 484         return 0;
 485 }
 486
 487 static int dummy_task_setscheduler (struct task_struct *p, int policy,
 488                                     struct sched_param *lp)
 489 {
 490         return 0;
 491 }
 492
 493 static int dummy_task_getscheduler (struct task_struct *p)
 494 {
 495         return 0;
 496 }
 497
 498 static int dummy_task_wait (struct task_struct *p)
 499 {
 500         return 0;
 501 }
 502
 503 static int dummy_task_kill (struct task_struct *p, struct siginfo *info,
 504                             int sig)
 505 {
 506         return 0;
 507 }
 508
 509 static int dummy_task_prctl (int option, unsigned long arg2, unsigned long arg3,
 510                              unsigned long arg4, unsigned long arg5)
 511 {
 512         return 0;
 513 }
 514
 515 static void dummy_task_reparent_to_init (struct task_struct *p)
 516 {
 517         p->euid = p->fsuid = 0;
 518         return;
 519 }
 520
 521 static void dummy_task_to_inode(struct task_struct *p, struct inode *inode)
 522 { }
 523
 524 static int dummy_ipc_permission (struct kern_ipc_perm *ipcp, short flag)
 525 {
 526         return 0;
 527 }
 528
 529 static int dummy_msg_msg_alloc_security (struct msg_msg *msg)
 530 {
 531         return 0;
 532 }
 533
 534 static void dummy_msg_msg_free_security (struct msg_msg *msg)
 535 {
 536         return;
 537 }
 538
 539 static int dummy_msg_queue_alloc_security (struct msg_queue *msq)
 540 {
 541         return 0;
 542 }
 543
 544 static void dummy_msg_queue_free_security (struct msg_queue *msq)
 545 {
 546         return;
 547 }
 548
 549 static int dummy_msg_queue_associate (struct msg_queue *msq,
 550                                       int msqflg)
 551 {
 552         return 0;
 553 }
 554
 555 static int dummy_msg_queue_msgctl (struct msg_queue *msq, int cmd)
 556 {
 557         return 0;
 558 }
 559
 560 static int dummy_msg_queue_msgsnd (struct msg_queue *msq, struct msg_msg *msg,
 561                                    int msgflg)
 562 {
 563         return 0;
 564 }
 565
 566 static int dummy_msg_queue_msgrcv (struct msg_queue *msq, struct msg_msg *msg,
 567                                    struct task_struct *target, long type,
 568                                    int mode)
 569 {
 570         return 0;
 571 }
 572
 573 static int dummy_shm_alloc_security (struct shmid_kernel *shp)
 574 {
 575         return 0;
 576 }
 577
 578 static void dummy_shm_free_security (struct shmid_kernel *shp)
 579 {
 580         return;
 581 }
 582
 583 static int dummy_shm_associate (struct shmid_kernel *shp, int shmflg)
 584 {
 585         return 0;
 586 }
 587
 588 static int dummy_shm_shmctl (struct shmid_kernel *shp, int cmd)
 589 {
 590         return 0;
 591 }
 592
 593 static int dummy_shm_shmat (struct shmid_kernel *shp, char *shmaddr,
 594                             int shmflg)
 595 {
 596         return 0;
 597 }
 598
 599 static int dummy_sem_alloc_security (struct sem_array *sma)
 600 {
 601         return 0;
 602 }
 603
 604 static void dummy_sem_free_security (struct sem_array *sma)
 605 {
 606         return;
 607 }
 608
 609 static int dummy_sem_associate (struct sem_array *sma, int semflg)
 610 {
 611         return 0;
 612 }
 613
 614 static int dummy_sem_semctl (struct sem_array *sma, int cmd)
 615 {
 616         return 0;
 617 }
 618
 619 static int dummy_sem_semop (struct sem_array *sma,
 620                             struct sembuf *sops, unsigned nsops, int alter)
 621 {
 622         return 0;
 623 }
 624
 625 static int dummy_netlink_send (struct sk_buff *skb)
 626 {
 627         if (current->euid == 0)
 628                 cap_raise (NETLINK_CB (skb).eff_cap, CAP_NET_ADMIN);
 629         else
 630                 NETLINK_CB (skb).eff_cap = 0;
 631         return 0;
 632 }
 633
 634 static int dummy_netlink_recv (struct sk_buff *skb)
 635 {
 636         if (!cap_raised (NETLINK_CB (skb).eff_cap, CAP_NET_ADMIN))
 637                 return -EPERM;
 638         return 0;
 639 }
 640
 641 #ifdef CONFIG_SECURITY_NETWORK
 642 static int dummy_unix_stream_connect (struct socket *sock,
 643                                       struct socket *other,
 644                                       struct sock *newsk)
 645 {
 646         return 0;
 647 }
 648
 649 static int dummy_unix_may_send (struct socket *sock,
 650                                 struct socket *other)
 651 {
 652         return 0;
 653 }
 654
 655 static int dummy_socket_create (int family, int type, int protocol)
 656 {
 657         return 0;
 658 }
 659
 660 static void dummy_socket_post_create (struct socket *sock, int family, int type,
 661                                       int protocol)
 662 {
 663         return;
 664 }
 665
 666 static int dummy_socket_bind (struct socket *sock, struct sockaddr *address,
 667                               int addrlen)
 668 {
 669         return 0;
 670 }
 671
 672 static int dummy_socket_connect (struct socket *sock, struct sockaddr *address,
 673                                  int addrlen)
 674 {
 675         return 0;
 676 }
 677
 678 static int dummy_socket_listen (struct socket *sock, int backlog)
 679 {
 680         return 0;
 681 }
 682
 683 static int dummy_socket_accept (struct socket *sock, struct socket *newsock)
 684 {
 685         return 0;
 686 }
 687
 688 static void dummy_socket_post_accept (struct socket *sock,
 689                                       struct socket *newsock)
 690 {
 691         return;
 692 }
 693
 694 static int dummy_socket_sendmsg (struct socket *sock, struct msghdr *msg,
 695                                  int size)
 696 {
 697         return 0;
 698 }
 699
 700 static int dummy_socket_recvmsg (struct socket *sock, struct msghdr *msg,
 701                                  int size, int flags)
 702 {
 703         return 0;
 704 }
 705
 706 static int dummy_socket_getsockname (struct socket *sock)
 707 {
 708         return 0;
 709 }
 710
 711 static int dummy_socket_getpeername (struct socket *sock)
 712 {
 713         return 0;
 714 }
 715
 716 static int dummy_socket_setsockopt (struct socket *sock, int level, int optname)
 717 {
 718         return 0;
 719 }
 720
 721 static int dummy_socket_getsockopt (struct socket *sock, int level, int optname)
 722 {
 723         return 0;
 724 }
 725
 726 static int dummy_socket_shutdown (struct socket *sock, int how)
 727 {
 728         return 0;
 729 }
 730
 731 static int dummy_socket_sock_rcv_skb (struct sock *sk, struct sk_buff *skb)
 732 {
 733         return 0;
 734 }
 735 #endif  /* CONFIG_SECURITY_NETWORK */
 736
 737 static int dummy_register_security (const char *name, struct security_operations *ops)
 738 {
 739         return -EINVAL;
 740 }
 741
 742 static int dummy_unregister_security (const char *name, struct security_operations *ops)
 743 {
 744         return -EINVAL;
 745 }
 746
 747 static void dummy_d_instantiate (struct dentry *dentry, struct inode *inode)
 748 {
 749         return;
 750 }
 751
 752 static int dummy_getprocattr(struct task_struct *p, char *name, void *value, size_t size)
 753 {
 754         return -EINVAL;
 755 }
 756
 757 static int dummy_setprocattr(struct task_struct *p, char *name, void *value, size_t size)
 758 {
 759         return -EINVAL;
 760 }
 761
 762
 763 struct security_operations dummy_security_ops;
 764
 765 #define set_to_dummy_if_null(ops, function)                             \
 766         do {                                                            \
 767                 if (!ops->function) {                                   \
 768                         ops->function = dummy_##function;               \
 769                         pr_debug("Had to override the " #function       \
 770                                  " security operation with the dummy one.\n");\
 771                         }                                               \
 772         } while (0)
 773
 774 void security_fixup_ops (struct security_operations *ops)
 775 {
 776         set_to_dummy_if_null(ops, ptrace);
 777         set_to_dummy_if_null(ops, capget);
 778         set_to_dummy_if_null(ops, capset_check);
 779         set_to_dummy_if_null(ops, capset_set);
 780         set_to_dummy_if_null(ops, acct);
 781         set_to_dummy_if_null(ops, capable);
 782         set_to_dummy_if_null(ops, quotactl);
 783         set_to_dummy_if_null(ops, quota_on);
 784         set_to_dummy_if_null(ops, sysctl);
 785         set_to_dummy_if_null(ops, syslog);
 786         set_to_dummy_if_null(ops, bprm_alloc_security);
 787         set_to_dummy_if_null(ops, bprm_free_security);
 788         set_to_dummy_if_null(ops, bprm_compute_creds);
 789         set_to_dummy_if_null(ops, bprm_set_security);
 790         set_to_dummy_if_null(ops, bprm_check_security);
 791         set_to_dummy_if_null(ops, sb_alloc_security);
 792         set_to_dummy_if_null(ops, sb_free_security);
 793         set_to_dummy_if_null(ops, sb_kern_mount);
 794         set_to_dummy_if_null(ops, sb_statfs);
 795         set_to_dummy_if_null(ops, sb_mount);
 796         set_to_dummy_if_null(ops, sb_check_sb);
 797         set_to_dummy_if_null(ops, sb_umount);
 798         set_to_dummy_if_null(ops, sb_umount_close);
 799         set_to_dummy_if_null(ops, sb_umount_busy);
 800         set_to_dummy_if_null(ops, sb_post_remount);
 801         set_to_dummy_if_null(ops, sb_post_mountroot);
 802         set_to_dummy_if_null(ops, sb_post_addmount);
 803         set_to_dummy_if_null(ops, sb_pivotroot);
 804         set_to_dummy_if_null(ops, sb_post_pivotroot);
 805         set_to_dummy_if_null(ops, inode_alloc_security);
 806         set_to_dummy_if_null(ops, inode_free_security);
 807         set_to_dummy_if_null(ops, inode_create);
 808         set_to_dummy_if_null(ops, inode_post_create);
 809         set_to_dummy_if_null(ops, inode_link);
 810         set_to_dummy_if_null(ops, inode_post_link);
 811         set_to_dummy_if_null(ops, inode_unlink);
 812         set_to_dummy_if_null(ops, inode_symlink);
 813         set_to_dummy_if_null(ops, inode_post_symlink);
 814         set_to_dummy_if_null(ops, inode_mkdir);
 815         set_to_dummy_if_null(ops, inode_post_mkdir);
 816         set_to_dummy_if_null(ops, inode_rmdir);
 817         set_to_dummy_if_null(ops, inode_mknod);
 818         set_to_dummy_if_null(ops, inode_post_mknod);
 819         set_to_dummy_if_null(ops, inode_rename);
 820         set_to_dummy_if_null(ops, inode_post_rename);
 821         set_to_dummy_if_null(ops, inode_readlink);
 822         set_to_dummy_if_null(ops, inode_follow_link);
 823         set_to_dummy_if_null(ops, inode_permission);
 824         set_to_dummy_if_null(ops, inode_setattr);
 825         set_to_dummy_if_null(ops, inode_getattr);
 826         set_to_dummy_if_null(ops, inode_delete);
 827         set_to_dummy_if_null(ops, inode_setxattr);
 828         set_to_dummy_if_null(ops, inode_post_setxattr);
 829         set_to_dummy_if_null(ops, inode_getxattr);
 830         set_to_dummy_if_null(ops, inode_listxattr);
 831         set_to_dummy_if_null(ops, inode_removexattr);
 832         set_to_dummy_if_null(ops, inode_getsecurity);
 833         set_to_dummy_if_null(ops, inode_setsecurity);
 834         set_to_dummy_if_null(ops, inode_listsecurity);
 835         set_to_dummy_if_null(ops, file_permission);
 836         set_to_dummy_if_null(ops, file_alloc_security);
 837         set_to_dummy_if_null(ops, file_free_security);
 838         set_to_dummy_if_null(ops, file_ioctl);
 839         set_to_dummy_if_null(ops, file_mmap);
 840         set_to_dummy_if_null(ops, file_mprotect);
 841         set_to_dummy_if_null(ops, file_lock);
 842         set_to_dummy_if_null(ops, file_fcntl);
 843         set_to_dummy_if_null(ops, file_set_fowner);
 844         set_to_dummy_if_null(ops, file_send_sigiotask);
 845         set_to_dummy_if_null(ops, file_receive);
 846         set_to_dummy_if_null(ops, task_create);
 847         set_to_dummy_if_null(ops, task_alloc_security);
 848         set_to_dummy_if_null(ops, task_free_security);
 849         set_to_dummy_if_null(ops, task_setuid);
 850         set_to_dummy_if_null(ops, task_post_setuid);
 851         set_to_dummy_if_null(ops, task_setgid);
 852         set_to_dummy_if_null(ops, task_setpgid);
 853         set_to_dummy_if_null(ops, task_getpgid);
 854         set_to_dummy_if_null(ops, task_getsid);
 855         set_to_dummy_if_null(ops, task_setgroups);
 856         set_to_dummy_if_null(ops, task_setnice);
 857         set_to_dummy_if_null(ops, task_setrlimit);
 858         set_to_dummy_if_null(ops, task_setscheduler);
 859         set_to_dummy_if_null(ops, task_getscheduler);
 860         set_to_dummy_if_null(ops, task_wait);
 861         set_to_dummy_if_null(ops, task_kill);
 862         set_to_dummy_if_null(ops, task_prctl);
 863         set_to_dummy_if_null(ops, task_reparent_to_init);
 864         set_to_dummy_if_null(ops, task_to_inode);
 865         set_to_dummy_if_null(ops, ipc_permission);
 866         set_to_dummy_if_null(ops, msg_msg_alloc_security);
 867         set_to_dummy_if_null(ops, msg_msg_free_security);
 868         set_to_dummy_if_null(ops, msg_queue_alloc_security);
 869         set_to_dummy_if_null(ops, msg_queue_free_security);
 870         set_to_dummy_if_null(ops, msg_queue_associate);
 871         set_to_dummy_if_null(ops, msg_queue_msgctl);
 872         set_to_dummy_if_null(ops, msg_queue_msgsnd);
 873         set_to_dummy_if_null(ops, msg_queue_msgrcv);
 874         set_to_dummy_if_null(ops, shm_alloc_security);
 875         set_to_dummy_if_null(ops, shm_free_security);
 876         set_to_dummy_if_null(ops, shm_associate);
 877         set_to_dummy_if_null(ops, shm_shmctl);
 878         set_to_dummy_if_null(ops, shm_shmat);
 879         set_to_dummy_if_null(ops, sem_alloc_security);
 880         set_to_dummy_if_null(ops, sem_free_security);
 881         set_to_dummy_if_null(ops, sem_associate);
 882         set_to_dummy_if_null(ops, sem_semctl);
 883         set_to_dummy_if_null(ops, sem_semop);
 884         set_to_dummy_if_null(ops, netlink_send);
 885         set_to_dummy_if_null(ops, netlink_recv);
 886         set_to_dummy_if_null(ops, register_security);
 887         set_to_dummy_if_null(ops, unregister_security);
 888         set_to_dummy_if_null(ops, d_instantiate);
 889         set_to_dummy_if_null(ops, getprocattr);
 890         set_to_dummy_if_null(ops, setprocattr);
 891 #ifdef CONFIG_SECURITY_NETWORK
 892         set_to_dummy_if_null(ops, unix_stream_connect);
 893         set_to_dummy_if_null(ops, unix_may_send);
 894         set_to_dummy_if_null(ops, socket_create);
 895         set_to_dummy_if_null(ops, socket_post_create);
 896         set_to_dummy_if_null(ops, socket_bind);
 897         set_to_dummy_if_null(ops, socket_connect);
 898         set_to_dummy_if_null(ops, socket_listen);
 899         set_to_dummy_if_null(ops, socket_accept);
 900         set_to_dummy_if_null(ops, socket_post_accept);
 901         set_to_dummy_if_null(ops, socket_sendmsg);
 902         set_to_dummy_if_null(ops, socket_recvmsg);
 903         set_to_dummy_if_null(ops, socket_getsockname);
 904         set_to_dummy_if_null(ops, socket_getpeername);
 905         set_to_dummy_if_null(ops, socket_setsockopt);
 906         set_to_dummy_if_null(ops, socket_getsockopt);
 907         set_to_dummy_if_null(ops, socket_shutdown);
 908         set_to_dummy_if_null(ops, socket_sock_rcv_skb);
 909 #endif  /* CONFIG_SECURITY_NETWORK */
 910 }
 911