security/smack/smackfs.c

   1 /*
   2  * Copyright (C) 2007 Casey Schaufler <casey@schaufler-ca.com>
   3  *
   4  *      This program is free software; you can redistribute it and/or modify
   5  *      it under the terms of the GNU General Public License as published by
   6  *      the Free Software Foundation, version 2.
   7  *
   8  * Authors:
   9  *      Casey Schaufler <casey@schaufler-ca.com>
  10  *      Ahmed S. Darwish <darwish.07@gmail.com>
  11  *
  12  * Special thanks to the authors of selinuxfs.
  13  *
  14  *      Karl MacMillan <kmacmillan@tresys.com>
  15  *      James Morris <jmorris@redhat.com>
  16  *
  17  */
  18
  19 #include <linux/kernel.h>
  20 #include <linux/vmalloc.h>
  21 #include <linux/security.h>
  22 #include <linux/mutex.h>
  23 #include <linux/slab.h>
  24 #include <net/net_namespace.h>
  25 #include <net/netlabel.h>
  26 #include <net/cipso_ipv4.h>
  27 #include <linux/seq_file.h>
  28 #include <linux/ctype.h>
  29 #include <linux/audit.h>
  30 #include "smack.h"
  31
  32 /*
  33  * smackfs pseudo filesystem.
  34  */
  35
  36 enum smk_inos {
  37         SMK_ROOT_INO    = 2,
  38         SMK_LOAD        = 3,    /* load policy */
  39         SMK_CIPSO       = 4,    /* load label -> CIPSO mapping */
  40         SMK_DOI         = 5,    /* CIPSO DOI */
  41         SMK_DIRECT      = 6,    /* CIPSO level indicating direct label */
  42         SMK_AMBIENT     = 7,    /* internet ambient label */
  43         SMK_NETLBLADDR  = 8,    /* single label hosts */
  44         SMK_ONLYCAP     = 9,    /* the only "capable" label */
  45         SMK_LOGGING     = 10,   /* logging */
  46         SMK_LOAD_SELF   = 11,   /* task specific rules */
  47 };
  48
  49 /*
  50  * List locks
  51  */
  52 static DEFINE_MUTEX(smack_list_lock);
  53 static DEFINE_MUTEX(smack_cipso_lock);
  54 static DEFINE_MUTEX(smack_ambient_lock);
  55 static DEFINE_MUTEX(smk_netlbladdr_lock);
  56
  57 /*
  58  * This is the "ambient" label for network traffic.
  59  * If it isn't somehow marked, use this.
  60  * It can be reset via smackfs/ambient
  61  */
  62 char *smack_net_ambient = smack_known_floor.smk_known;
  63
  64 /*
  65  * This is the level in a CIPSO header that indicates a
  66  * smack label is contained directly in the category set.
  67  * It can be reset via smackfs/direct
  68  */
  69 int smack_cipso_direct = SMACK_CIPSO_DIRECT_DEFAULT;
  70
  71 /*
  72  * Unless a process is running with this label even
  73  * having CAP_MAC_OVERRIDE isn't enough to grant
  74  * privilege to violate MAC policy. If no label is
  75  * designated (the NULL case) capabilities apply to
  76  * everyone. It is expected that the hat (^) label
  77  * will be used if any label is used.
  78  */
  79 char *smack_onlycap;
  80
  81 /*
  82  * Certain IP addresses may be designated as single label hosts.
  83  * Packets are sent there unlabeled, but only from tasks that
  84  * can write to the specified label.
  85  */
  86
  87 LIST_HEAD(smk_netlbladdr_list);
  88 LIST_HEAD(smack_rule_list);
  89
  90 static int smk_cipso_doi_value = SMACK_CIPSO_DOI_DEFAULT;
  91
  92 const char *smack_cipso_option = SMACK_CIPSO_OPTION;
  93
  94
  95 #define SEQ_READ_FINISHED       1
  96
  97 /*
  98  * Values for parsing cipso rules
  99  * SMK_DIGITLEN: Length of a digit field in a rule.
 100  * SMK_CIPSOMIN: Minimum possible cipso rule length.
 101  * SMK_CIPSOMAX: Maximum possible cipso rule length.
 102  */
 103 #define SMK_DIGITLEN 4
 104 #define SMK_CIPSOMIN (SMK_LABELLEN + 2 * SMK_DIGITLEN)
 105 #define SMK_CIPSOMAX (SMK_CIPSOMIN + SMACK_CIPSO_MAXCATNUM * SMK_DIGITLEN)
 106
 107 /*
 108  * Values for parsing MAC rules
 109  * SMK_ACCESS: Maximum possible combination of access permissions
 110  * SMK_ACCESSLEN: Maximum length for a rule access field
 111  * SMK_LOADLEN: Smack rule length
 112  */
 113 #define SMK_OACCESS     "rwxa"
 114 #define SMK_ACCESS      "rwxat"
 115 #define SMK_OACCESSLEN  (sizeof(SMK_OACCESS) - 1)
 116 #define SMK_ACCESSLEN   (sizeof(SMK_ACCESS) - 1)
 117 #define SMK_OLOADLEN    (SMK_LABELLEN + SMK_LABELLEN + SMK_OACCESSLEN)
 118 #define SMK_LOADLEN     (SMK_LABELLEN + SMK_LABELLEN + SMK_ACCESSLEN)
 119
 120 /**
 121  * smk_netlabel_audit_set - fill a netlbl_audit struct
 122  * @nap: structure to fill
 123  */
 124 static void smk_netlabel_audit_set(struct netlbl_audit *nap)
 125 {
 126         nap->loginuid = audit_get_loginuid(current);
 127         nap->sessionid = audit_get_sessionid(current);
 128         nap->secid = smack_to_secid(smk_of_current());
 129 }
 130
 131 /*
 132  * Values for parsing single label host rules
 133  * "1.2.3.4 X"
 134  * "192.168.138.129/32 abcdefghijklmnopqrstuvw"
 135  */
 136 #define SMK_NETLBLADDRMIN       9
 137 #define SMK_NETLBLADDRMAX       42
 138
 139 /**
 140  * smk_set_access - add a rule to the rule list
 141  * @srp: the new rule to add
 142  * @rule_list: the list of rules
 143  * @rule_lock: the rule list lock
 144  *
 145  * Looks through the current subject/object/access list for
 146  * the subject/object pair and replaces the access that was
 147  * there. If the pair isn't found add it with the specified
 148  * access.
 149  *
 150  * Returns 1 if a rule was found to exist already, 0 if it is new
 151  * Returns 0 if nothing goes wrong or -ENOMEM if it fails
 152  * during the allocation of the new pair to add.
 153  */
 154 static int smk_set_access(struct smack_rule *srp, struct list_head *rule_list,
 155                                 struct mutex *rule_lock)
 156 {
 157         struct smack_rule *sp;
 158         int found = 0;
 159
 160         mutex_lock(rule_lock);
 161
 162         list_for_each_entry_rcu(sp, rule_list, list) {
 163                 if (sp->smk_subject == srp->smk_subject &&
 164                     sp->smk_object == srp->smk_object) {
 165                         found = 1;
 166                         sp->smk_access = srp->smk_access;
 167                         break;
 168                 }
 169         }
 170         if (found == 0)
 171                 list_add_rcu(&srp->list, rule_list);
 172
 173         mutex_unlock(rule_lock);
 174
 175         return found;
 176 }
 177
 178 /**
 179  * smk_write_load_list - write() for any /smack/load
 180  * @file: file pointer, not actually used
 181  * @buf: where to get the data from
 182  * @count: bytes sent
 183  * @ppos: where to start - must be 0
 184  * @rule_list: the list of rules to write to
 185  * @rule_lock: lock for the rule list
 186  *
 187  * Get one smack access rule from above.
 188  * The format is exactly:
 189  *     char subject[SMK_LABELLEN]
 190  *     char object[SMK_LABELLEN]
 191  *     char access[SMK_ACCESSLEN]
 192  *
 193  * writes must be SMK_LABELLEN+SMK_LABELLEN+SMK_ACCESSLEN bytes.
 194  */
 195 static ssize_t smk_write_load_list(struct file *file, const char __user *buf,
 196                                 size_t count, loff_t *ppos,
 197                                 struct list_head *rule_list,
 198                                 struct mutex *rule_lock)
 199 {
 200         struct smack_rule *rule;
 201         char *data;
 202         int rc = -EINVAL;
 203
 204         /*
 205          * No partial writes.
 206          * Enough data must be present.
 207          */
 208         if (*ppos != 0)
 209                 return -EINVAL;
 210         /*
 211          * Minor hack for backward compatibility
 212          */
 213         if (count < (SMK_OLOADLEN) || count > SMK_LOADLEN)
 214                 return -EINVAL;
 215
 216         data = kzalloc(SMK_LOADLEN, GFP_KERNEL);
 217         if (data == NULL)
 218                 return -ENOMEM;
 219
 220         if (copy_from_user(data, buf, count) != 0) {
 221                 rc = -EFAULT;
 222                 goto out;
 223         }
 224
 225         /*
 226          * More on the minor hack for backward compatibility
 227          */
 228         if (count == (SMK_OLOADLEN))
 229                 data[SMK_OLOADLEN] = '-';
 230
 231         rule = kzalloc(sizeof(*rule), GFP_KERNEL);
 232         if (rule == NULL) {
 233                 rc = -ENOMEM;
 234                 goto out;
 235         }
 236
 237         rule->smk_subject = smk_import(data, 0);
 238         if (rule->smk_subject == NULL)
 239                 goto out_free_rule;
 240
 241         rule->smk_object = smk_import(data + SMK_LABELLEN, 0);
 242         if (rule->smk_object == NULL)
 243                 goto out_free_rule;
 244
 245         rule->smk_access = 0;
 246
 247         switch (data[SMK_LABELLEN + SMK_LABELLEN]) {
 248         case '-':
 249                 break;
 250         case 'r':
 251         case 'R':
 252                 rule->smk_access |= MAY_READ;
 253                 break;
 254         default:
 255                 goto out_free_rule;
 256         }
 257
 258         switch (data[SMK_LABELLEN + SMK_LABELLEN + 1]) {
 259         case '-':
 260                 break;
 261         case 'w':
 262         case 'W':
 263                 rule->smk_access |= MAY_WRITE;
 264                 break;
 265         default:
 266                 goto out_free_rule;
 267         }
 268
 269         switch (data[SMK_LABELLEN + SMK_LABELLEN + 2]) {
 270         case '-':
 271                 break;
 272         case 'x':
 273         case 'X':
 274                 rule->smk_access |= MAY_EXEC;
 275                 break;
 276         default:
 277                 goto out_free_rule;
 278         }
 279
 280         switch (data[SMK_LABELLEN + SMK_LABELLEN + 3]) {
 281         case '-':
 282                 break;
 283         case 'a':
 284         case 'A':
 285                 rule->smk_access |= MAY_APPEND;
 286                 break;
 287         default:
 288                 goto out_free_rule;
 289         }
 290
 291         switch (data[SMK_LABELLEN + SMK_LABELLEN + 4]) {
 292         case '-':
 293                 break;
 294         case 't':
 295         case 'T':
 296                 rule->smk_access |= MAY_TRANSMUTE;
 297                 break;
 298         default:
 299                 goto out_free_rule;
 300         }
 301
 302         rc = count;
 303         /*
 304          * smk_set_access returns true if there was already a rule
 305          * for the subject/object pair, and false if it was new.
 306          */
 307         if (!smk_set_access(rule, rule_list, rule_lock))
 308                 goto out;
 309
 310 out_free_rule:
 311         kfree(rule);
 312 out:
 313         kfree(data);
 314         return rc;
 315 }
 316
 317
 318 /*
 319  * Seq_file read operations for /smack/load
 320  */
 321
 322 static void *load_seq_start(struct seq_file *s, loff_t *pos)
 323 {
 324         if (*pos == SEQ_READ_FINISHED)
 325                 return NULL;
 326         if (list_empty(&smack_rule_list))
 327                 return NULL;
 328         return smack_rule_list.next;
 329 }
 330
 331 static void *load_seq_next(struct seq_file *s, void *v, loff_t *pos)
 332 {
 333         struct list_head *list = v;
 334
 335         if (list_is_last(list, &smack_rule_list)) {
 336                 *pos = SEQ_READ_FINISHED;
 337                 return NULL;
 338         }
 339         return list->next;
 340 }
 341
 342 static int load_seq_show(struct seq_file *s, void *v)
 343 {
 344         struct list_head *list = v;
 345         struct smack_rule *srp =
 346                  list_entry(list, struct smack_rule, list);
 347
 348         seq_printf(s, "%s %s", (char *)srp->smk_subject,
 349                    (char *)srp->smk_object);
 350
 351         seq_putc(s, ' ');
 352
 353         if (srp->smk_access & MAY_READ)
 354                 seq_putc(s, 'r');
 355         if (srp->smk_access & MAY_WRITE)
 356                 seq_putc(s, 'w');
 357         if (srp->smk_access & MAY_EXEC)
 358                 seq_putc(s, 'x');
 359         if (srp->smk_access & MAY_APPEND)
 360                 seq_putc(s, 'a');
 361         if (srp->smk_access & MAY_TRANSMUTE)
 362                 seq_putc(s, 't');
 363         if (srp->smk_access == 0)
 364                 seq_putc(s, '-');
 365
 366         seq_putc(s, '\n');
 367
 368         return 0;
 369 }
 370
 371 static void load_seq_stop(struct seq_file *s, void *v)
 372 {
 373         /* No-op */
 374 }
 375
 376 static const struct seq_operations load_seq_ops = {
 377         .start = load_seq_start,
 378         .next  = load_seq_next,
 379         .show  = load_seq_show,
 380         .stop  = load_seq_stop,
 381 };
 382
 383 /**
 384  * smk_open_load - open() for /smack/load
 385  * @inode: inode structure representing file
 386  * @file: "load" file pointer
 387  *
 388  * For reading, use load_seq_* seq_file reading operations.
 389  */
 390 static int smk_open_load(struct inode *inode, struct file *file)
 391 {
 392         return seq_open(file, &load_seq_ops);
 393 }
 394
 395 /**
 396  * smk_write_load - write() for /smack/load
 397  * @file: file pointer, not actually used
 398  * @buf: where to get the data from
 399  * @count: bytes sent
 400  * @ppos: where to start - must be 0
 401  *
 402  */
 403 static ssize_t smk_write_load(struct file *file, const char __user *buf,
 404                               size_t count, loff_t *ppos)
 405 {
 406
 407         /*
 408          * Must have privilege.
 409          * No partial writes.
 410          * Enough data must be present.
 411          */
 412         if (!capable(CAP_MAC_ADMIN))
 413                 return -EPERM;
 414
 415         return smk_write_load_list(file, buf, count, ppos, &smack_rule_list,
 416                                         &smack_list_lock);
 417 }
 418
 419 static const struct file_operations smk_load_ops = {
 420         .open           = smk_open_load,
 421         .read           = seq_read,
 422         .llseek         = seq_lseek,
 423         .write          = smk_write_load,
 424         .release        = seq_release,
 425 };
 426
 427 /**
 428  * smk_cipso_doi - initialize the CIPSO domain
 429  */
 430 static void smk_cipso_doi(void)
 431 {
 432         int rc;
 433         struct cipso_v4_doi *doip;
 434         struct netlbl_audit nai;
 435
 436         smk_netlabel_audit_set(&nai);
 437
 438         rc = netlbl_cfg_map_del(NULL, PF_INET, NULL, NULL, &nai);
 439         if (rc != 0)
 440                 printk(KERN_WARNING "%s:%d remove rc = %d\n",
 441                        __func__, __LINE__, rc);
 442
 443         doip = kmalloc(sizeof(struct cipso_v4_doi), GFP_KERNEL);
 444         if (doip == NULL)
 445                 panic("smack:  Failed to initialize cipso DOI.\n");
 446         doip->map.std = NULL;
 447         doip->doi = smk_cipso_doi_value;
 448         doip->type = CIPSO_V4_MAP_PASS;
 449         doip->tags[0] = CIPSO_V4_TAG_RBITMAP;
 450         for (rc = 1; rc < CIPSO_V4_TAG_MAXCNT; rc++)
 451                 doip->tags[rc] = CIPSO_V4_TAG_INVALID;
 452
 453         rc = netlbl_cfg_cipsov4_add(doip, &nai);
 454         if (rc != 0) {
 455                 printk(KERN_WARNING "%s:%d cipso add rc = %d\n",
 456                        __func__, __LINE__, rc);
 457                 kfree(doip);
 458                 return;
 459         }
 460         rc = netlbl_cfg_cipsov4_map_add(doip->doi, NULL, NULL, NULL, &nai);
 461         if (rc != 0) {
 462                 printk(KERN_WARNING "%s:%d map add rc = %d\n",
 463                        __func__, __LINE__, rc);
 464                 kfree(doip);
 465                 return;
 466         }
 467 }
 468
 469 /**
 470  * smk_unlbl_ambient - initialize the unlabeled domain
 471  * @oldambient: previous domain string
 472  */
 473 static void smk_unlbl_ambient(char *oldambient)
 474 {
 475         int rc;
 476         struct netlbl_audit nai;
 477
 478         smk_netlabel_audit_set(&nai);
 479
 480         if (oldambient != NULL) {
 481                 rc = netlbl_cfg_map_del(oldambient, PF_INET, NULL, NULL, &nai);
 482                 if (rc != 0)
 483                         printk(KERN_WARNING "%s:%d remove rc = %d\n",
 484                                __func__, __LINE__, rc);
 485         }
 486
 487         rc = netlbl_cfg_unlbl_map_add(smack_net_ambient, PF_INET,
 488                                       NULL, NULL, &nai);
 489         if (rc != 0)
 490                 printk(KERN_WARNING "%s:%d add rc = %d\n",
 491                        __func__, __LINE__, rc);
 492 }
 493
 494 /*
 495  * Seq_file read operations for /smack/cipso
 496  */
 497
 498 static void *cipso_seq_start(struct seq_file *s, loff_t *pos)
 499 {
 500         if (*pos == SEQ_READ_FINISHED)
 501                 return NULL;
 502         if (list_empty(&smack_known_list))
 503                 return NULL;
 504
 505         return smack_known_list.next;
 506 }
 507
 508 static void *cipso_seq_next(struct seq_file *s, void *v, loff_t *pos)
 509 {
 510         struct list_head  *list = v;
 511
 512         /*
 513          * labels with no associated cipso value wont be printed
 514          * in cipso_seq_show
 515          */
 516         if (list_is_last(list, &smack_known_list)) {
 517                 *pos = SEQ_READ_FINISHED;
 518                 return NULL;
 519         }
 520
 521         return list->next;
 522 }
 523
 524 /*
 525  * Print cipso labels in format:
 526  * label level[/cat[,cat]]
 527  */
 528 static int cipso_seq_show(struct seq_file *s, void *v)
 529 {
 530         struct list_head  *list = v;
 531         struct smack_known *skp =
 532                  list_entry(list, struct smack_known, list);
 533         struct smack_cipso *scp = skp->smk_cipso;
 534         char *cbp;
 535         char sep = '/';
 536         int cat = 1;
 537         int i;
 538         unsigned char m;
 539
 540         if (scp == NULL)
 541                 return 0;
 542
 543         seq_printf(s, "%s %3d", (char *)&skp->smk_known, scp->smk_level);
 544
 545         cbp = scp->smk_catset;
 546         for (i = 0; i < SMK_LABELLEN; i++)
 547                 for (m = 0x80; m != 0; m >>= 1) {
 548                         if (m & cbp[i]) {
 549                                 seq_printf(s, "%c%d", sep, cat);
 550                                 sep = ',';
 551                         }
 552                         cat++;
 553                 }
 554
 555         seq_putc(s, '\n');
 556
 557         return 0;
 558 }
 559
 560 static void cipso_seq_stop(struct seq_file *s, void *v)
 561 {
 562         /* No-op */
 563 }
 564
 565 static const struct seq_operations cipso_seq_ops = {
 566         .start = cipso_seq_start,
 567         .stop  = cipso_seq_stop,
 568         .next  = cipso_seq_next,
 569         .show  = cipso_seq_show,
 570 };
 571
 572 /**
 573  * smk_open_cipso - open() for /smack/cipso
 574  * @inode: inode structure representing file
 575  * @file: "cipso" file pointer
 576  *
 577  * Connect our cipso_seq_* operations with /smack/cipso
 578  * file_operations
 579  */
 580 static int smk_open_cipso(struct inode *inode, struct file *file)
 581 {
 582         return seq_open(file, &cipso_seq_ops);
 583 }
 584
 585 /**
 586  * smk_write_cipso - write() for /smack/cipso
 587  * @file: file pointer, not actually used
 588  * @buf: where to get the data from
 589  * @count: bytes sent
 590  * @ppos: where to start
 591  *
 592  * Accepts only one cipso rule per write call.
 593  * Returns number of bytes written or error code, as appropriate
 594  */
 595 static ssize_t smk_write_cipso(struct file *file, const char __user *buf,
 596                                size_t count, loff_t *ppos)
 597 {
 598         struct smack_known *skp;
 599         struct smack_cipso *scp = NULL;
 600         char mapcatset[SMK_LABELLEN];
 601         int maplevel;
 602         int cat;
 603         int catlen;
 604         ssize_t rc = -EINVAL;
 605         char *data = NULL;
 606         char *rule;
 607         int ret;
 608         int i;
 609
 610         /*
 611          * Must have privilege.
 612          * No partial writes.
 613          * Enough data must be present.
 614          */
 615         if (!capable(CAP_MAC_ADMIN))
 616                 return -EPERM;
 617         if (*ppos != 0)
 618                 return -EINVAL;
 619         if (count < SMK_CIPSOMIN || count > SMK_CIPSOMAX)
 620                 return -EINVAL;
 621
 622         data = kzalloc(count + 1, GFP_KERNEL);
 623         if (data == NULL)
 624                 return -ENOMEM;
 625
 626         if (copy_from_user(data, buf, count) != 0) {
 627                 rc = -EFAULT;
 628                 goto unlockedout;
 629         }
 630
 631         /* labels cannot begin with a '-' */
 632         if (data[0] == '-') {
 633                 rc = -EINVAL;
 634                 goto unlockedout;
 635         }
 636         data[count] = '\0';
 637         rule = data;
 638         /*
 639          * Only allow one writer at a time. Writes should be
 640          * quite rare and small in any case.
 641          */
 642         mutex_lock(&smack_cipso_lock);
 643
 644         skp = smk_import_entry(rule, 0);
 645         if (skp == NULL)
 646                 goto out;
 647
 648         rule += SMK_LABELLEN;
 649         ret = sscanf(rule, "%d", &maplevel);
 650         if (ret != 1 || maplevel > SMACK_CIPSO_MAXLEVEL)
 651                 goto out;
 652
 653         rule += SMK_DIGITLEN;
 654         ret = sscanf(rule, "%d", &catlen);
 655         if (ret != 1 || catlen > SMACK_CIPSO_MAXCATNUM)
 656                 goto out;
 657
 658         if (count != (SMK_CIPSOMIN + catlen * SMK_DIGITLEN))
 659                 goto out;
 660
 661         memset(mapcatset, 0, sizeof(mapcatset));
 662
 663         for (i = 0; i < catlen; i++) {
 664                 rule += SMK_DIGITLEN;
 665                 ret = sscanf(rule, "%d", &cat);
 666                 if (ret != 1 || cat > SMACK_CIPSO_MAXCATVAL)
 667                         goto out;
 668
 669                 smack_catset_bit(cat, mapcatset);
 670         }
 671
 672         if (skp->smk_cipso == NULL) {
 673                 scp = kzalloc(sizeof(struct smack_cipso), GFP_KERNEL);
 674                 if (scp == NULL) {
 675                         rc = -ENOMEM;
 676                         goto out;
 677                 }
 678         }
 679
 680         spin_lock_bh(&skp->smk_cipsolock);
 681
 682         if (scp == NULL)
 683                 scp = skp->smk_cipso;
 684         else
 685                 skp->smk_cipso = scp;
 686
 687         scp->smk_level = maplevel;
 688         memcpy(scp->smk_catset, mapcatset, sizeof(mapcatset));
 689
 690         spin_unlock_bh(&skp->smk_cipsolock);
 691
 692         rc = count;
 693 out:
 694         mutex_unlock(&smack_cipso_lock);
 695 unlockedout:
 696         kfree(data);
 697         return rc;
 698 }
 699
 700 static const struct file_operations smk_cipso_ops = {
 701         .open           = smk_open_cipso,
 702         .read           = seq_read,
 703         .llseek         = seq_lseek,
 704         .write          = smk_write_cipso,
 705         .release        = seq_release,
 706 };
 707
 708 /*
 709  * Seq_file read operations for /smack/netlabel
 710  */
 711
 712 static void *netlbladdr_seq_start(struct seq_file *s, loff_t *pos)
 713 {
 714         if (*pos == SEQ_READ_FINISHED)
 715                 return NULL;
 716         if (list_empty(&smk_netlbladdr_list))
 717                 return NULL;
 718         return smk_netlbladdr_list.next;
 719 }
 720
 721 static void *netlbladdr_seq_next(struct seq_file *s, void *v, loff_t *pos)
 722 {
 723         struct list_head *list = v;
 724
 725         if (list_is_last(list, &smk_netlbladdr_list)) {
 726                 *pos = SEQ_READ_FINISHED;
 727                 return NULL;
 728         }
 729
 730         return list->next;
 731 }
 732 #define BEBITS  (sizeof(__be32) * 8)
 733
 734 /*
 735  * Print host/label pairs
 736  */
 737 static int netlbladdr_seq_show(struct seq_file *s, void *v)
 738 {
 739         struct list_head *list = v;
 740         struct smk_netlbladdr *skp =
 741                          list_entry(list, struct smk_netlbladdr, list);
 742         unsigned char *hp = (char *) &skp->smk_host.sin_addr.s_addr;
 743         int maskn;
 744         u32 temp_mask = be32_to_cpu(skp->smk_mask.s_addr);
 745
 746         for (maskn = 0; temp_mask; temp_mask <<= 1, maskn++);
 747
 748         seq_printf(s, "%u.%u.%u.%u/%d %s\n",
 749                 hp[0], hp[1], hp[2], hp[3], maskn, skp->smk_label);
 750
 751         return 0;
 752 }
 753
 754 static void netlbladdr_seq_stop(struct seq_file *s, void *v)
 755 {
 756         /* No-op */
 757 }
 758
 759 static const struct seq_operations netlbladdr_seq_ops = {
 760         .start = netlbladdr_seq_start,
 761         .stop  = netlbladdr_seq_stop,
 762         .next  = netlbladdr_seq_next,
 763         .show  = netlbladdr_seq_show,
 764 };
 765
 766 /**
 767  * smk_open_netlbladdr - open() for /smack/netlabel
 768  * @inode: inode structure representing file
 769  * @file: "netlabel" file pointer
 770  *
 771  * Connect our netlbladdr_seq_* operations with /smack/netlabel
 772  * file_operations
 773  */
 774 static int smk_open_netlbladdr(struct inode *inode, struct file *file)
 775 {
 776         return seq_open(file, &netlbladdr_seq_ops);
 777 }
 778
 779 /**
 780  * smk_netlbladdr_insert
 781  * @new : netlabel to insert
 782  *
 783  * This helper insert netlabel in the smack_netlbladdrs list
 784  * sorted by netmask length (longest to smallest)
 785  * locked by &smk_netlbladdr_lock in smk_write_netlbladdr
 786  *
 787  */
 788 static void smk_netlbladdr_insert(struct smk_netlbladdr *new)
 789 {
 790         struct smk_netlbladdr *m, *m_next;
 791
 792         if (list_empty(&smk_netlbladdr_list)) {
 793                 list_add_rcu(&new->list, &smk_netlbladdr_list);
 794                 return;
 795         }
 796
 797         m = list_entry_rcu(smk_netlbladdr_list.next,
 798                            struct smk_netlbladdr, list);
 799
 800         /* the comparison '>' is a bit hacky, but works */
 801         if (new->smk_mask.s_addr > m->smk_mask.s_addr) {
 802                 list_add_rcu(&new->list, &smk_netlbladdr_list);
 803                 return;
 804         }
 805
 806         list_for_each_entry_rcu(m, &smk_netlbladdr_list, list) {
 807                 if (list_is_last(&m->list, &smk_netlbladdr_list)) {
 808                         list_add_rcu(&new->list, &m->list);
 809                         return;
 810                 }
 811                 m_next = list_entry_rcu(m->list.next,
 812                                         struct smk_netlbladdr, list);
 813                 if (new->smk_mask.s_addr > m_next->smk_mask.s_addr) {
 814                         list_add_rcu(&new->list, &m->list);
 815                         return;
 816                 }
 817         }
 818 }
 819
 820
 821 /**
 822  * smk_write_netlbladdr - write() for /smack/netlabel
 823  * @file: file pointer, not actually used
 824  * @buf: where to get the data from
 825  * @count: bytes sent
 826  * @ppos: where to start
 827  *
 828  * Accepts only one netlbladdr per write call.
 829  * Returns number of bytes written or error code, as appropriate
 830  */
 831 static ssize_t smk_write_netlbladdr(struct file *file, const char __user *buf,
 832                                 size_t count, loff_t *ppos)
 833 {
 834         struct smk_netlbladdr *skp;
 835         struct sockaddr_in newname;
 836         char smack[SMK_LABELLEN];
 837         char *sp;
 838         char data[SMK_NETLBLADDRMAX + 1];
 839         char *host = (char *)&newname.sin_addr.s_addr;
 840         int rc;
 841         struct netlbl_audit audit_info;
 842         struct in_addr mask;
 843         unsigned int m;
 844         int found;
 845         u32 mask_bits = (1<<31);
 846         __be32 nsa;
 847         u32 temp_mask;
 848
 849         /*
 850          * Must have privilege.
 851          * No partial writes.
 852          * Enough data must be present.
 853          * "<addr/mask, as a.b.c.d/e><space><label>"
 854          * "<addr, as a.b.c.d><space><label>"
 855          */
 856         if (!capable(CAP_MAC_ADMIN))
 857                 return -EPERM;
 858         if (*ppos != 0)
 859                 return -EINVAL;
 860         if (count < SMK_NETLBLADDRMIN || count > SMK_NETLBLADDRMAX)
 861                 return -EINVAL;
 862         if (copy_from_user(data, buf, count) != 0)
 863                 return -EFAULT;
 864
 865         data[count] = '\0';
 866
 867         rc = sscanf(data, "%hhd.%hhd.%hhd.%hhd/%d %s",
 868                 &host[0], &host[1], &host[2], &host[3], &m, smack);
 869         if (rc != 6) {
 870                 rc = sscanf(data, "%hhd.%hhd.%hhd.%hhd %s",
 871                         &host[0], &host[1], &host[2], &host[3], smack);
 872                 if (rc != 5)
 873                         return -EINVAL;
 874                 m = BEBITS;
 875         }
 876         if (m > BEBITS)
 877                 return -EINVAL;
 878
 879         /* if smack begins with '-', its an option, don't import it */
 880         if (smack[0] != '-') {
 881                 sp = smk_import(smack, 0);
 882                 if (sp == NULL)
 883                         return -EINVAL;
 884         } else {
 885                 /* check known options */
 886                 if (strcmp(smack, smack_cipso_option) == 0)
 887                         sp = (char *)smack_cipso_option;
 888                 else
 889                         return -EINVAL;
 890         }
 891
 892         for (temp_mask = 0; m > 0; m--) {
 893                 temp_mask |= mask_bits;
 894                 mask_bits >>= 1;
 895         }
 896         mask.s_addr = cpu_to_be32(temp_mask);
 897
 898         newname.sin_addr.s_addr &= mask.s_addr;
 899         /*
 900          * Only allow one writer at a time. Writes should be
 901          * quite rare and small in any case.
 902          */
 903         mutex_lock(&smk_netlbladdr_lock);
 904
 905         nsa = newname.sin_addr.s_addr;
 906         /* try to find if the prefix is already in the list */
 907         found = 0;
 908         list_for_each_entry_rcu(skp, &smk_netlbladdr_list, list) {
 909                 if (skp->smk_host.sin_addr.s_addr == nsa &&
 910                     skp->smk_mask.s_addr == mask.s_addr) {
 911                         found = 1;
 912                         break;
 913                 }
 914         }
 915         smk_netlabel_audit_set(&audit_info);
 916
 917         if (found == 0) {
 918                 skp = kzalloc(sizeof(*skp), GFP_KERNEL);
 919                 if (skp == NULL)
 920                         rc = -ENOMEM;
 921                 else {
 922                         rc = 0;
 923                         skp->smk_host.sin_addr.s_addr = newname.sin_addr.s_addr;
 924                         skp->smk_mask.s_addr = mask.s_addr;
 925                         skp->smk_label = sp;
 926                         smk_netlbladdr_insert(skp);
 927                 }
 928         } else {
 929                 /* we delete the unlabeled entry, only if the previous label
 930                  * wasn't the special CIPSO option */
 931                 if (skp->smk_label != smack_cipso_option)
 932                         rc = netlbl_cfg_unlbl_static_del(&init_net, NULL,
 933                                         &skp->smk_host.sin_addr, &skp->smk_mask,
 934                                         PF_INET, &audit_info);
 935                 else
 936                         rc = 0;
 937                 skp->smk_label = sp;
 938         }
 939
 940         /*
 941          * Now tell netlabel about the single label nature of
 942          * this host so that incoming packets get labeled.
 943          * but only if we didn't get the special CIPSO option
 944          */
 945         if (rc == 0 && sp != smack_cipso_option)
 946                 rc = netlbl_cfg_unlbl_static_add(&init_net, NULL,
 947                         &skp->smk_host.sin_addr, &skp->smk_mask, PF_INET,
 948                         smack_to_secid(skp->smk_label), &audit_info);
 949
 950         if (rc == 0)
 951                 rc = count;
 952
 953         mutex_unlock(&smk_netlbladdr_lock);
 954
 955         return rc;
 956 }
 957
 958 static const struct file_operations smk_netlbladdr_ops = {
 959         .open           = smk_open_netlbladdr,
 960         .read           = seq_read,
 961         .llseek         = seq_lseek,
 962         .write          = smk_write_netlbladdr,
 963         .release        = seq_release,
 964 };
 965
 966 /**
 967  * smk_read_doi - read() for /smack/doi
 968  * @filp: file pointer, not actually used
 969  * @buf: where to put the result
 970  * @count: maximum to send along
 971  * @ppos: where to start
 972  *
 973  * Returns number of bytes read or error code, as appropriate
 974  */
 975 static ssize_t smk_read_doi(struct file *filp, char __user *buf,
 976                             size_t count, loff_t *ppos)
 977 {
 978         char temp[80];
 979         ssize_t rc;
 980
 981         if (*ppos != 0)
 982                 return 0;
 983
 984         sprintf(temp, "%d", smk_cipso_doi_value);
 985         rc = simple_read_from_buffer(buf, count, ppos, temp, strlen(temp));
 986
 987         return rc;
 988 }
 989
 990 /**
 991  * smk_write_doi - write() for /smack/doi
 992  * @file: file pointer, not actually used
 993  * @buf: where to get the data from
 994  * @count: bytes sent
 995  * @ppos: where to start
 996  *
 997  * Returns number of bytes written or error code, as appropriate
 998  */
 999 static ssize_t smk_write_doi(struct file *file, const char __user *buf,
1000                              size_t count, loff_t *ppos)
1001 {
1002         char temp[80];
1003         int i;
1004
1005         if (!capable(CAP_MAC_ADMIN))
1006                 return -EPERM;
1007
1008         if (count >= sizeof(temp) || count == 0)
1009                 return -EINVAL;
1010
1011         if (copy_from_user(temp, buf, count) != 0)
1012                 return -EFAULT;
1013
1014         temp[count] = '\0';
1015
1016         if (sscanf(temp, "%d", &i) != 1)
1017                 return -EINVAL;
1018
1019         smk_cipso_doi_value = i;
1020
1021         smk_cipso_doi();
1022
1023         return count;
1024 }
1025
1026 static const struct file_operations smk_doi_ops = {
1027         .read           = smk_read_doi,
1028         .write          = smk_write_doi,
1029         .llseek         = default_llseek,
1030 };
1031
1032 /**
1033  * smk_read_direct - read() for /smack/direct
1034  * @filp: file pointer, not actually used
1035  * @buf: where to put the result
1036  * @count: maximum to send along
1037  * @ppos: where to start
1038  *
1039  * Returns number of bytes read or error code, as appropriate
1040  */
1041 static ssize_t smk_read_direct(struct file *filp, char __user *buf,
1042                                size_t count, loff_t *ppos)
1043 {
1044         char temp[80];
1045         ssize_t rc;
1046
1047         if (*ppos != 0)
1048                 return 0;
1049
1050         sprintf(temp, "%d", smack_cipso_direct);
1051         rc = simple_read_from_buffer(buf, count, ppos, temp, strlen(temp));
1052
1053         return rc;
1054 }
1055
1056 /**
1057  * smk_write_direct - write() for /smack/direct
1058  * @file: file pointer, not actually used
1059  * @buf: where to get the data from
1060  * @count: bytes sent
1061  * @ppos: where to start
1062  *
1063  * Returns number of bytes written or error code, as appropriate
1064  */
1065 static ssize_t smk_write_direct(struct file *file, const char __user *buf,
1066                                 size_t count, loff_t *ppos)
1067 {
1068         char temp[80];
1069         int i;
1070
1071         if (!capable(CAP_MAC_ADMIN))
1072                 return -EPERM;
1073
1074         if (count >= sizeof(temp) || count == 0)
1075                 return -EINVAL;
1076
1077         if (copy_from_user(temp, buf, count) != 0)
1078                 return -EFAULT;
1079
1080         temp[count] = '\0';
1081
1082         if (sscanf(temp, "%d", &i) != 1)
1083                 return -EINVAL;
1084
1085         smack_cipso_direct = i;
1086
1087         return count;
1088 }
1089
1090 static const struct file_operations smk_direct_ops = {
1091         .read           = smk_read_direct,
1092         .write          = smk_write_direct,
1093         .llseek         = default_llseek,
1094 };
1095
1096 /**
1097  * smk_read_ambient - read() for /smack/ambient
1098  * @filp: file pointer, not actually used
1099  * @buf: where to put the result
1100  * @cn: maximum to send along
1101  * @ppos: where to start
1102  *
1103  * Returns number of bytes read or error code, as appropriate
1104  */
1105 static ssize_t smk_read_ambient(struct file *filp, char __user *buf,
1106                                 size_t cn, loff_t *ppos)
1107 {
1108         ssize_t rc;
1109         int asize;
1110
1111         if (*ppos != 0)
1112                 return 0;
1113         /*
1114          * Being careful to avoid a problem in the case where
1115          * smack_net_ambient gets changed in midstream.
1116          */
1117         mutex_lock(&smack_ambient_lock);
1118
1119         asize = strlen(smack_net_ambient) + 1;
1120
1121         if (cn >= asize)
1122                 rc = simple_read_from_buffer(buf, cn, ppos,
1123                                              smack_net_ambient, asize);
1124         else
1125                 rc = -EINVAL;
1126
1127         mutex_unlock(&smack_ambient_lock);
1128
1129         return rc;
1130 }
1131
1132 /**
1133  * smk_write_ambient - write() for /smack/ambient
1134  * @file: file pointer, not actually used
1135  * @buf: where to get the data from
1136  * @count: bytes sent
1137  * @ppos: where to start
1138  *
1139  * Returns number of bytes written or error code, as appropriate
1140  */
1141 static ssize_t smk_write_ambient(struct file *file, const char __user *buf,
1142                                  size_t count, loff_t *ppos)
1143 {
1144         char in[SMK_LABELLEN];
1145         char *oldambient;
1146         char *smack;
1147
1148         if (!capable(CAP_MAC_ADMIN))
1149                 return -EPERM;
1150
1151         if (count >= SMK_LABELLEN)
1152                 return -EINVAL;
1153
1154         if (copy_from_user(in, buf, count) != 0)
1155                 return -EFAULT;
1156
1157         smack = smk_import(in, count);
1158         if (smack == NULL)
1159                 return -EINVAL;
1160
1161         mutex_lock(&smack_ambient_lock);
1162
1163         oldambient = smack_net_ambient;
1164         smack_net_ambient = smack;
1165         smk_unlbl_ambient(oldambient);
1166
1167         mutex_unlock(&smack_ambient_lock);
1168
1169         return count;
1170 }
1171
1172 static const struct file_operations smk_ambient_ops = {
1173         .read           = smk_read_ambient,
1174         .write          = smk_write_ambient,
1175         .llseek         = default_llseek,
1176 };
1177
1178 /**
1179  * smk_read_onlycap - read() for /smack/onlycap
1180  * @filp: file pointer, not actually used
1181  * @buf: where to put the result
1182  * @cn: maximum to send along
1183  * @ppos: where to start
1184  *
1185  * Returns number of bytes read or error code, as appropriate
1186  */
1187 static ssize_t smk_read_onlycap(struct file *filp, char __user *buf,
1188                                 size_t cn, loff_t *ppos)
1189 {
1190         char *smack = "";
1191         ssize_t rc = -EINVAL;
1192         int asize;
1193
1194         if (*ppos != 0)
1195                 return 0;
1196
1197         if (smack_onlycap != NULL)
1198                 smack = smack_onlycap;
1199
1200         asize = strlen(smack) + 1;
1201
1202         if (cn >= asize)
1203                 rc = simple_read_from_buffer(buf, cn, ppos, smack, asize);
1204
1205         return rc;
1206 }
1207
1208 /**
1209  * smk_write_onlycap - write() for /smack/onlycap
1210  * @file: file pointer, not actually used
1211  * @buf: where to get the data from
1212  * @count: bytes sent
1213  * @ppos: where to start
1214  *
1215  * Returns number of bytes written or error code, as appropriate
1216  */
1217 static ssize_t smk_write_onlycap(struct file *file, const char __user *buf,
1218                                  size_t count, loff_t *ppos)
1219 {
1220         char in[SMK_LABELLEN];
1221         char *sp = smk_of_task(current->cred->security);
1222
1223         if (!capable(CAP_MAC_ADMIN))
1224                 return -EPERM;
1225
1226         /*
1227          * This can be done using smk_access() but is done
1228          * explicitly for clarity. The smk_access() implementation
1229          * would use smk_access(smack_onlycap, MAY_WRITE)
1230          */
1231         if (smack_onlycap != NULL && smack_onlycap != sp)
1232                 return -EPERM;
1233
1234         if (count >= SMK_LABELLEN)
1235                 return -EINVAL;
1236
1237         if (copy_from_user(in, buf, count) != 0)
1238                 return -EFAULT;
1239
1240         /*
1241          * Should the null string be passed in unset the onlycap value.
1242          * This seems like something to be careful with as usually
1243          * smk_import only expects to return NULL for errors. It
1244          * is usually the case that a nullstring or "\n" would be
1245          * bad to pass to smk_import but in fact this is useful here.
1246          */
1247         smack_onlycap = smk_import(in, count);
1248
1249         return count;
1250 }
1251
1252 static const struct file_operations smk_onlycap_ops = {
1253         .read           = smk_read_onlycap,
1254         .write          = smk_write_onlycap,
1255         .llseek         = default_llseek,
1256 };
1257
1258 /**
1259  * smk_read_logging - read() for /smack/logging
1260  * @filp: file pointer, not actually used
1261  * @buf: where to put the result
1262  * @cn: maximum to send along
1263  * @ppos: where to start
1264  *
1265  * Returns number of bytes read or error code, as appropriate
1266  */
1267 static ssize_t smk_read_logging(struct file *filp, char __user *buf,
1268                                 size_t count, loff_t *ppos)
1269 {
1270         char temp[32];
1271         ssize_t rc;
1272
1273         if (*ppos != 0)
1274                 return 0;
1275
1276         sprintf(temp, "%d\n", log_policy);
1277         rc = simple_read_from_buffer(buf, count, ppos, temp, strlen(temp));
1278         return rc;
1279 }
1280
1281 /**
1282  * smk_write_logging - write() for /smack/logging
1283  * @file: file pointer, not actually used
1284  * @buf: where to get the data from
1285  * @count: bytes sent
1286  * @ppos: where to start
1287  *
1288  * Returns number of bytes written or error code, as appropriate
1289  */
1290 static ssize_t smk_write_logging(struct file *file, const char __user *buf,
1291                                 size_t count, loff_t *ppos)
1292 {
1293         char temp[32];
1294         int i;
1295
1296         if (!capable(CAP_MAC_ADMIN))
1297                 return -EPERM;
1298
1299         if (count >= sizeof(temp) || count == 0)
1300                 return -EINVAL;
1301
1302         if (copy_from_user(temp, buf, count) != 0)
1303                 return -EFAULT;
1304
1305         temp[count] = '\0';
1306
1307         if (sscanf(temp, "%d", &i) != 1)
1308                 return -EINVAL;
1309         if (i < 0 || i > 3)
1310                 return -EINVAL;
1311         log_policy = i;
1312         return count;
1313 }
1314
1315
1316
1317 static const struct file_operations smk_logging_ops = {
1318         .read           = smk_read_logging,
1319         .write          = smk_write_logging,
1320         .llseek         = default_llseek,
1321 };
1322
1323 /*
1324  * Seq_file read operations for /smack/load-self
1325  */
1326
1327 static void *load_self_seq_start(struct seq_file *s, loff_t *pos)
1328 {
1329         struct task_smack *tsp = current_security();
1330
1331         if (*pos == SEQ_READ_FINISHED)
1332                 return NULL;
1333         if (list_empty(&tsp->smk_rules))
1334                 return NULL;
1335         return tsp->smk_rules.next;
1336 }
1337
1338 static void *load_self_seq_next(struct seq_file *s, void *v, loff_t *pos)
1339 {
1340         struct task_smack *tsp = current_security();
1341         struct list_head *list = v;
1342
1343         if (list_is_last(list, &tsp->smk_rules)) {
1344                 *pos = SEQ_READ_FINISHED;
1345                 return NULL;
1346         }
1347         return list->next;
1348 }
1349
1350 static int load_self_seq_show(struct seq_file *s, void *v)
1351 {
1352         struct list_head *list = v;
1353         struct smack_rule *srp =
1354                  list_entry(list, struct smack_rule, list);
1355
1356         seq_printf(s, "%s %s", (char *)srp->smk_subject,
1357                    (char *)srp->smk_object);
1358
1359         seq_putc(s, ' ');
1360
1361         if (srp->smk_access & MAY_READ)
1362                 seq_putc(s, 'r');
1363         if (srp->smk_access & MAY_WRITE)
1364                 seq_putc(s, 'w');
1365         if (srp->smk_access & MAY_EXEC)
1366                 seq_putc(s, 'x');
1367         if (srp->smk_access & MAY_APPEND)
1368                 seq_putc(s, 'a');
1369         if (srp->smk_access & MAY_TRANSMUTE)
1370                 seq_putc(s, 't');
1371         if (srp->smk_access == 0)
1372                 seq_putc(s, '-');
1373
1374         seq_putc(s, '\n');
1375
1376         return 0;
1377 }
1378
1379 static void load_self_seq_stop(struct seq_file *s, void *v)
1380 {
1381         /* No-op */
1382 }
1383
1384 static const struct seq_operations load_self_seq_ops = {
1385         .start = load_self_seq_start,
1386         .next  = load_self_seq_next,
1387         .show  = load_self_seq_show,
1388         .stop  = load_self_seq_stop,
1389 };
1390
1391
1392 /**
1393  * smk_open_load_self - open() for /smack/load-self
1394  * @inode: inode structure representing file
1395  * @file: "load" file pointer
1396  *
1397  * For reading, use load_seq_* seq_file reading operations.
1398  */
1399 static int smk_open_load_self(struct inode *inode, struct file *file)
1400 {
1401         return seq_open(file, &load_self_seq_ops);
1402 }
1403
1404 /**
1405  * smk_write_load_self - write() for /smack/load-self
1406  * @file: file pointer, not actually used
1407  * @buf: where to get the data from
1408  * @count: bytes sent
1409  * @ppos: where to start - must be 0
1410  *
1411  */
1412 static ssize_t smk_write_load_self(struct file *file, const char __user *buf,
1413                               size_t count, loff_t *ppos)
1414 {
1415         struct task_smack *tsp = current_security();
1416
1417         return smk_write_load_list(file, buf, count, ppos, &tsp->smk_rules,
1418                                         &tsp->smk_rules_lock);
1419 }
1420
1421 static const struct file_operations smk_load_self_ops = {
1422         .open           = smk_open_load_self,
1423         .read           = seq_read,
1424         .llseek         = seq_lseek,
1425         .write          = smk_write_load_self,
1426         .release        = seq_release,
1427 };
1428 /**
1429  * smk_fill_super - fill the /smackfs superblock
1430  * @sb: the empty superblock
1431  * @data: unused
1432  * @silent: unused
1433  *
1434  * Fill in the well known entries for /smack
1435  *
1436  * Returns 0 on success, an error code on failure
1437  */
1438 static int smk_fill_super(struct super_block *sb, void *data, int silent)
1439 {
1440         int rc;
1441         struct inode *root_inode;
1442
1443         static struct tree_descr smack_files[] = {
1444                 [SMK_LOAD] = {
1445                         "load", &smk_load_ops, S_IRUGO|S_IWUSR},
1446                 [SMK_CIPSO] = {
1447                         "cipso", &smk_cipso_ops, S_IRUGO|S_IWUSR},
1448                 [SMK_DOI] = {
1449                         "doi", &smk_doi_ops, S_IRUGO|S_IWUSR},
1450                 [SMK_DIRECT] = {
1451                         "direct", &smk_direct_ops, S_IRUGO|S_IWUSR},
1452                 [SMK_AMBIENT] = {
1453                         "ambient", &smk_ambient_ops, S_IRUGO|S_IWUSR},
1454                 [SMK_NETLBLADDR] = {
1455                         "netlabel", &smk_netlbladdr_ops, S_IRUGO|S_IWUSR},
1456                 [SMK_ONLYCAP] = {
1457                         "onlycap", &smk_onlycap_ops, S_IRUGO|S_IWUSR},
1458                 [SMK_LOGGING] = {
1459                         "logging", &smk_logging_ops, S_IRUGO|S_IWUSR},
1460                 [SMK_LOAD_SELF] = {
1461                         "load-self", &smk_load_self_ops, S_IRUGO|S_IWUGO},
1462                 /* last one */
1463                         {""}
1464         };
1465
1466         rc = simple_fill_super(sb, SMACK_MAGIC, smack_files);
1467         if (rc != 0) {
1468                 printk(KERN_ERR "%s failed %d while creating inodes\n",
1469                         __func__, rc);
1470                 return rc;
1471         }
1472
1473         root_inode = sb->s_root->d_inode;
1474         root_inode->i_security = new_inode_smack(smack_known_floor.smk_known);
1475
1476         return 0;
1477 }
1478
1479 /**
1480  * smk_mount - get the smackfs superblock
1481  * @fs_type: passed along without comment
1482  * @flags: passed along without comment
1483  * @dev_name: passed along without comment
1484  * @data: passed along without comment
1485  *
1486  * Just passes everything along.
1487  *
1488  * Returns what the lower level code does.
1489  */
1490 static struct dentry *smk_mount(struct file_system_type *fs_type,
1491                       int flags, const char *dev_name, void *data)
1492 {
1493         return mount_single(fs_type, flags, data, smk_fill_super);
1494 }
1495
1496 static struct file_system_type smk_fs_type = {
1497         .name           = "smackfs",
1498         .mount          = smk_mount,
1499         .kill_sb        = kill_litter_super,
1500 };
1501
1502 static struct vfsmount *smackfs_mount;
1503
1504 /**
1505  * init_smk_fs - get the smackfs superblock
1506  *
1507  * register the smackfs
1508  *
1509  * Do not register smackfs if Smack wasn't enabled
1510  * on boot. We can not put this method normally under the
1511  * smack_init() code path since the security subsystem get
1512  * initialized before the vfs caches.
1513  *
1514  * Returns true if we were not chosen on boot or if
1515  * we were chosen and filesystem registration succeeded.
1516  */
1517 static int __init init_smk_fs(void)
1518 {
1519         int err;
1520
1521         if (!security_module_enable(&smack_ops))
1522                 return 0;
1523
1524         err = register_filesystem(&smk_fs_type);
1525         if (!err) {
1526                 smackfs_mount = kern_mount(&smk_fs_type);
1527                 if (IS_ERR(smackfs_mount)) {
1528                         printk(KERN_ERR "smackfs:  could not mount!\n");
1529                         err = PTR_ERR(smackfs_mount);
1530                         smackfs_mount = NULL;
1531                 }
1532         }
1533
1534         smk_cipso_doi();
1535         smk_unlbl_ambient(NULL);
1536
1537         return err;
1538 }
1539
1540 __initcall(init_smk_fs);