security/smack/smackfs.c

   1 // SPDX-License-Identifier: GPL-2.0-only
   2 /*
   3  * Copyright (C) 2007 Casey Schaufler <casey@schaufler-ca.com>
   4  *
   5  * Authors:
   6  *      Casey Schaufler <casey@schaufler-ca.com>
   7  *      Ahmed S. Darwish <darwish.07@gmail.com>
   8  *
   9  * Special thanks to the authors of selinuxfs.
  10  *
  11  *      Karl MacMillan <kmacmillan@tresys.com>
  12  *      James Morris <jmorris@redhat.com>
  13  */
  14
  15 #include <linux/kernel.h>
  16 #include <linux/vmalloc.h>
  17 #include <linux/security.h>
  18 #include <linux/mutex.h>
  19 #include <linux/slab.h>
  20 #include <net/net_namespace.h>
  21 #include <net/cipso_ipv4.h>
  22 #include <linux/seq_file.h>
  23 #include <linux/ctype.h>
  24 #include <linux/audit.h>
  25 #include <linux/magic.h>
  26 #include <linux/fs_context.h>
  27 #include "smack.h"
  28
  29 #define BEBITS  (sizeof(__be32) * 8)
  30 /*
  31  * smackfs pseudo filesystem.
  32  */
  33
  34 enum smk_inos {
  35         SMK_ROOT_INO    = 2,
  36         SMK_LOAD        = 3,    /* load policy */
  37         SMK_CIPSO       = 4,    /* load label -> CIPSO mapping */
  38         SMK_DOI         = 5,    /* CIPSO DOI */
  39         SMK_DIRECT      = 6,    /* CIPSO level indicating direct label */
  40         SMK_AMBIENT     = 7,    /* internet ambient label */
  41         SMK_NET4ADDR    = 8,    /* single label hosts */
  42         SMK_ONLYCAP     = 9,    /* the only "capable" label */
  43         SMK_LOGGING     = 10,   /* logging */
  44         SMK_LOAD_SELF   = 11,   /* task specific rules */
  45         SMK_ACCESSES    = 12,   /* access policy */
  46         SMK_MAPPED      = 13,   /* CIPSO level indicating mapped label */
  47         SMK_LOAD2       = 14,   /* load policy with long labels */
  48         SMK_LOAD_SELF2  = 15,   /* load task specific rules with long labels */
  49         SMK_ACCESS2     = 16,   /* make an access check with long labels */
  50         SMK_CIPSO2      = 17,   /* load long label -> CIPSO mapping */
  51         SMK_REVOKE_SUBJ = 18,   /* set rules with subject label to '-' */
  52         SMK_CHANGE_RULE = 19,   /* change or add rules (long labels) */
  53         SMK_SYSLOG      = 20,   /* change syslog label) */
  54         SMK_PTRACE      = 21,   /* set ptrace rule */
  55 #ifdef CONFIG_SECURITY_SMACK_BRINGUP
  56         SMK_UNCONFINED  = 22,   /* define an unconfined label */
  57 #endif
  58 #if IS_ENABLED(CONFIG_IPV6)
  59         SMK_NET6ADDR    = 23,   /* single label IPv6 hosts */
  60 #endif /* CONFIG_IPV6 */
  61         SMK_RELABEL_SELF = 24, /* relabel possible without CAP_MAC_ADMIN */
  62 };
  63
  64 /*
  65  * List locks
  66  */
  67 static DEFINE_MUTEX(smack_cipso_lock);
  68 static DEFINE_MUTEX(smack_ambient_lock);
  69 static DEFINE_MUTEX(smk_net4addr_lock);
  70 #if IS_ENABLED(CONFIG_IPV6)
  71 static DEFINE_MUTEX(smk_net6addr_lock);
  72 #endif /* CONFIG_IPV6 */
  73
  74 /*
  75  * This is the "ambient" label for network traffic.
  76  * If it isn't somehow marked, use this.
  77  * It can be reset via smackfs/ambient
  78  */
  79 struct smack_known *smack_net_ambient;
  80
  81 /*
  82  * This is the level in a CIPSO header that indicates a
  83  * smack label is contained directly in the category set.
  84  * It can be reset via smackfs/direct
  85  */
  86 int smack_cipso_direct = SMACK_CIPSO_DIRECT_DEFAULT;
  87
  88 /*
  89  * This is the level in a CIPSO header that indicates a
  90  * secid is contained directly in the category set.
  91  * It can be reset via smackfs/mapped
  92  */
  93 int smack_cipso_mapped = SMACK_CIPSO_MAPPED_DEFAULT;
  94
  95 #ifdef CONFIG_SECURITY_SMACK_BRINGUP
  96 /*
  97  * Allow one label to be unconfined. This is for
  98  * debugging and application bring-up purposes only.
  99  * It is bad and wrong, but everyone seems to expect
 100  * to have it.
 101  */
 102 struct smack_known *smack_unconfined;
 103 #endif
 104
 105 /*
 106  * If this value is set restrict syslog use to the label specified.
 107  * It can be reset via smackfs/syslog
 108  */
 109 struct smack_known *smack_syslog_label;
 110
 111 /*
 112  * Ptrace current rule
 113  * SMACK_PTRACE_DEFAULT    regular smack ptrace rules (/proc based)
 114  * SMACK_PTRACE_EXACT      labels must match, but can be overriden with
 115  *                         CAP_SYS_PTRACE
 116  * SMACK_PTRACE_DRACONIAN  lables must match, CAP_SYS_PTRACE has no effect
 117  */
 118 int smack_ptrace_rule = SMACK_PTRACE_DEFAULT;
 119
 120 /*
 121  * Certain IP addresses may be designated as single label hosts.
 122  * Packets are sent there unlabeled, but only from tasks that
 123  * can write to the specified label.
 124  */
 125
 126 LIST_HEAD(smk_net4addr_list);
 127 #if IS_ENABLED(CONFIG_IPV6)
 128 LIST_HEAD(smk_net6addr_list);
 129 #endif /* CONFIG_IPV6 */
 130
 131 /*
 132  * Rule lists are maintained for each label.
 133  */
 134 struct smack_parsed_rule {
 135         struct smack_known      *smk_subject;
 136         struct smack_known      *smk_object;
 137         int                     smk_access1;
 138         int                     smk_access2;
 139 };
 140
 141 static int smk_cipso_doi_value = SMACK_CIPSO_DOI_DEFAULT;
 142
 143 /*
 144  * Values for parsing cipso rules
 145  * SMK_DIGITLEN: Length of a digit field in a rule.
 146  * SMK_CIPSOMIN: Minimum possible cipso rule length.
 147  * SMK_CIPSOMAX: Maximum possible cipso rule length.
 148  */
 149 #define SMK_DIGITLEN 4
 150 #define SMK_CIPSOMIN (SMK_LABELLEN + 2 * SMK_DIGITLEN)
 151 #define SMK_CIPSOMAX (SMK_CIPSOMIN + SMACK_CIPSO_MAXCATNUM * SMK_DIGITLEN)
 152
 153 /*
 154  * Values for parsing MAC rules
 155  * SMK_ACCESS: Maximum possible combination of access permissions
 156  * SMK_ACCESSLEN: Maximum length for a rule access field
 157  * SMK_LOADLEN: Smack rule length
 158  */
 159 #define SMK_OACCESS     "rwxa"
 160 #define SMK_ACCESS      "rwxatl"
 161 #define SMK_OACCESSLEN  (sizeof(SMK_OACCESS) - 1)
 162 #define SMK_ACCESSLEN   (sizeof(SMK_ACCESS) - 1)
 163 #define SMK_OLOADLEN    (SMK_LABELLEN + SMK_LABELLEN + SMK_OACCESSLEN)
 164 #define SMK_LOADLEN     (SMK_LABELLEN + SMK_LABELLEN + SMK_ACCESSLEN)
 165
 166 /*
 167  * Stricly for CIPSO level manipulation.
 168  * Set the category bit number in a smack label sized buffer.
 169  */
 170 static inline void smack_catset_bit(unsigned int cat, char *catsetp)
 171 {
 172         if (cat == 0 || cat > (SMK_CIPSOLEN * 8))
 173                 return;
 174
 175         catsetp[(cat - 1) / 8] |= 0x80 >> ((cat - 1) % 8);
 176 }
 177
 178 /**
 179  * smk_netlabel_audit_set - fill a netlbl_audit struct
 180  * @nap: structure to fill
 181  */
 182 static void smk_netlabel_audit_set(struct netlbl_audit *nap)
 183 {
 184         struct smack_known *skp = smk_of_current();
 185
 186         nap->loginuid = audit_get_loginuid(current);
 187         nap->sessionid = audit_get_sessionid(current);
 188         nap->secid = skp->smk_secid;
 189 }
 190
 191 /*
 192  * Value for parsing single label host rules
 193  * "1.2.3.4 X"
 194  */
 195 #define SMK_NETLBLADDRMIN       9
 196
 197 /**
 198  * smk_set_access - add a rule to the rule list or replace an old rule
 199  * @srp: the rule to add or replace
 200  * @rule_list: the list of rules
 201  * @rule_lock: the rule list lock
 202  *
 203  * Looks through the current subject/object/access list for
 204  * the subject/object pair and replaces the access that was
 205  * there. If the pair isn't found add it with the specified
 206  * access.
 207  *
 208  * Returns 0 if nothing goes wrong or -ENOMEM if it fails
 209  * during the allocation of the new pair to add.
 210  */
 211 static int smk_set_access(struct smack_parsed_rule *srp,
 212                                 struct list_head *rule_list,
 213                                 struct mutex *rule_lock)
 214 {
 215         struct smack_rule *sp;
 216         int found = 0;
 217         int rc = 0;
 218
 219         mutex_lock(rule_lock);
 220
 221         /*
 222          * Because the object label is less likely to match
 223          * than the subject label check it first
 224          */
 225         list_for_each_entry_rcu(sp, rule_list, list) {
 226                 if (sp->smk_object == srp->smk_object &&
 227                     sp->smk_subject == srp->smk_subject) {
 228                         found = 1;
 229                         sp->smk_access |= srp->smk_access1;
 230                         sp->smk_access &= ~srp->smk_access2;
 231                         break;
 232                 }
 233         }
 234
 235         if (found == 0) {
 236                 sp = kmem_cache_zalloc(smack_rule_cache, GFP_KERNEL);
 237                 if (sp == NULL) {
 238                         rc = -ENOMEM;
 239                         goto out;
 240                 }
 241
 242                 sp->smk_subject = srp->smk_subject;
 243                 sp->smk_object = srp->smk_object;
 244                 sp->smk_access = srp->smk_access1 & ~srp->smk_access2;
 245
 246                 list_add_rcu(&sp->list, rule_list);
 247         }
 248
 249 out:
 250         mutex_unlock(rule_lock);
 251         return rc;
 252 }
 253
 254 /**
 255  * smk_perm_from_str - parse smack accesses from a text string
 256  * @string: a text string that contains a Smack accesses code
 257  *
 258  * Returns an integer with respective bits set for specified accesses.
 259  */
 260 static int smk_perm_from_str(const char *string)
 261 {
 262         int perm = 0;
 263         const char *cp;
 264
 265         for (cp = string; ; cp++)
 266                 switch (*cp) {
 267                 case '-':
 268                         break;
 269                 case 'r':
 270                 case 'R':
 271                         perm |= MAY_READ;
 272                         break;
 273                 case 'w':
 274                 case 'W':
 275                         perm |= MAY_WRITE;
 276                         break;
 277                 case 'x':
 278                 case 'X':
 279                         perm |= MAY_EXEC;
 280                         break;
 281                 case 'a':
 282                 case 'A':
 283                         perm |= MAY_APPEND;
 284                         break;
 285                 case 't':
 286                 case 'T':
 287                         perm |= MAY_TRANSMUTE;
 288                         break;
 289                 case 'l':
 290                 case 'L':
 291                         perm |= MAY_LOCK;
 292                         break;
 293                 case 'b':
 294                 case 'B':
 295                         perm |= MAY_BRINGUP;
 296                         break;
 297                 default:
 298                         return perm;
 299                 }
 300 }
 301
 302 /**
 303  * smk_fill_rule - Fill Smack rule from strings
 304  * @subject: subject label string
 305  * @object: object label string
 306  * @access1: access string
 307  * @access2: string with permissions to be removed
 308  * @rule: Smack rule
 309  * @import: if non-zero, import labels
 310  * @len: label length limit
 311  *
 312  * Returns 0 on success, appropriate error code on failure.
 313  */
 314 static int smk_fill_rule(const char *subject, const char *object,
 315                                 const char *access1, const char *access2,
 316                                 struct smack_parsed_rule *rule, int import,
 317                                 int len)
 318 {
 319         const char *cp;
 320         struct smack_known *skp;
 321
 322         if (import) {
 323                 rule->smk_subject = smk_import_entry(subject, len);
 324                 if (IS_ERR(rule->smk_subject))
 325                         return PTR_ERR(rule->smk_subject);
 326
 327                 rule->smk_object = smk_import_entry(object, len);
 328                 if (IS_ERR(rule->smk_object))
 329                         return PTR_ERR(rule->smk_object);
 330         } else {
 331                 cp = smk_parse_smack(subject, len);
 332                 if (IS_ERR(cp))
 333                         return PTR_ERR(cp);
 334                 skp = smk_find_entry(cp);
 335                 kfree(cp);
 336                 if (skp == NULL)
 337                         return -ENOENT;
 338                 rule->smk_subject = skp;
 339
 340                 cp = smk_parse_smack(object, len);
 341                 if (IS_ERR(cp))
 342                         return PTR_ERR(cp);
 343                 skp = smk_find_entry(cp);
 344                 kfree(cp);
 345                 if (skp == NULL)
 346                         return -ENOENT;
 347                 rule->smk_object = skp;
 348         }
 349
 350         rule->smk_access1 = smk_perm_from_str(access1);
 351         if (access2)
 352                 rule->smk_access2 = smk_perm_from_str(access2);
 353         else
 354                 rule->smk_access2 = ~rule->smk_access1;
 355
 356         return 0;
 357 }
 358
 359 /**
 360  * smk_parse_rule - parse Smack rule from load string
 361  * @data: string to be parsed whose size is SMK_LOADLEN
 362  * @rule: Smack rule
 363  * @import: if non-zero, import labels
 364  *
 365  * Returns 0 on success, -1 on errors.
 366  */
 367 static int smk_parse_rule(const char *data, struct smack_parsed_rule *rule,
 368                                 int import)
 369 {
 370         int rc;
 371
 372         rc = smk_fill_rule(data, data + SMK_LABELLEN,
 373                            data + SMK_LABELLEN + SMK_LABELLEN, NULL, rule,
 374                            import, SMK_LABELLEN);
 375         return rc;
 376 }
 377
 378 /**
 379  * smk_parse_long_rule - parse Smack rule from rule string
 380  * @data: string to be parsed, null terminated
 381  * @rule: Will be filled with Smack parsed rule
 382  * @import: if non-zero, import labels
 383  * @tokens: numer of substrings expected in data
 384  *
 385  * Returns number of processed bytes on success, -ERRNO on failure.
 386  */
 387 static ssize_t smk_parse_long_rule(char *data, struct smack_parsed_rule *rule,
 388                                 int import, int tokens)
 389 {
 390         ssize_t cnt = 0;
 391         char *tok[4];
 392         int rc;
 393         int i;
 394
 395         /*
 396          * Parsing the rule in-place, filling all white-spaces with '\0'
 397          */
 398         for (i = 0; i < tokens; ++i) {
 399                 while (isspace(data[cnt]))
 400                         data[cnt++] = '\0';
 401
 402                 if (data[cnt] == '\0')
 403                         /* Unexpected end of data */
 404                         return -EINVAL;
 405
 406                 tok[i] = data + cnt;
 407
 408                 while (data[cnt] && !isspace(data[cnt]))
 409                         ++cnt;
 410         }
 411         while (isspace(data[cnt]))
 412                 data[cnt++] = '\0';
 413
 414         while (i < 4)
 415                 tok[i++] = NULL;
 416
 417         rc = smk_fill_rule(tok[0], tok[1], tok[2], tok[3], rule, import, 0);
 418         return rc == 0 ? cnt : rc;
 419 }
 420
 421 #define SMK_FIXED24_FMT 0       /* Fixed 24byte label format */
 422 #define SMK_LONG_FMT    1       /* Variable long label format */
 423 #define SMK_CHANGE_FMT  2       /* Rule modification format */
 424 /**
 425  * smk_write_rules_list - write() for any /smack rule file
 426  * @file: file pointer, not actually used
 427  * @buf: where to get the data from
 428  * @count: bytes sent
 429  * @ppos: where to start - must be 0
 430  * @rule_list: the list of rules to write to
 431  * @rule_lock: lock for the rule list
 432  * @format: /smack/load or /smack/load2 or /smack/change-rule format.
 433  *
 434  * Get one smack access rule from above.
 435  * The format for SMK_LONG_FMT is:
 436  *      "subject<whitespace>object<whitespace>access[<whitespace>...]"
 437  * The format for SMK_FIXED24_FMT is exactly:
 438  *      "subject                 object                  rwxat"
 439  * The format for SMK_CHANGE_FMT is:
 440  *      "subject<whitespace>object<whitespace>
 441  *       acc_enable<whitespace>acc_disable[<whitespace>...]"
 442  */
 443 static ssize_t smk_write_rules_list(struct file *file, const char __user *buf,
 444                                         size_t count, loff_t *ppos,
 445                                         struct list_head *rule_list,
 446                                         struct mutex *rule_lock, int format)
 447 {
 448         struct smack_parsed_rule rule;
 449         char *data;
 450         int rc;
 451         int trunc = 0;
 452         int tokens;
 453         ssize_t cnt = 0;
 454
 455         /*
 456          * No partial writes.
 457          * Enough data must be present.
 458          */
 459         if (*ppos != 0)
 460                 return -EINVAL;
 461
 462         if (format == SMK_FIXED24_FMT) {
 463                 /*
 464                  * Minor hack for backward compatibility
 465                  */
 466                 if (count < SMK_OLOADLEN || count > SMK_LOADLEN)
 467                         return -EINVAL;
 468         } else {
 469                 if (count >= PAGE_SIZE) {
 470                         count = PAGE_SIZE - 1;
 471                         trunc = 1;
 472                 }
 473         }
 474
 475         data = memdup_user_nul(buf, count);
 476         if (IS_ERR(data))
 477                 return PTR_ERR(data);
 478
 479         /*
 480          * In case of parsing only part of user buf,
 481          * avoid having partial rule at the data buffer
 482          */
 483         if (trunc) {
 484                 while (count > 0 && (data[count - 1] != '\n'))
 485                         --count;
 486                 if (count == 0) {
 487                         rc = -EINVAL;
 488                         goto out;
 489                 }
 490         }
 491
 492         data[count] = '\0';
 493         tokens = (format == SMK_CHANGE_FMT ? 4 : 3);
 494         while (cnt < count) {
 495                 if (format == SMK_FIXED24_FMT) {
 496                         rc = smk_parse_rule(data, &rule, 1);
 497                         if (rc < 0)
 498                                 goto out;
 499                         cnt = count;
 500                 } else {
 501                         rc = smk_parse_long_rule(data + cnt, &rule, 1, tokens);
 502                         if (rc < 0)
 503                                 goto out;
 504                         if (rc == 0) {
 505                                 rc = -EINVAL;
 506                                 goto out;
 507                         }
 508                         cnt += rc;
 509                 }
 510
 511                 if (rule_list == NULL)
 512                         rc = smk_set_access(&rule, &rule.smk_subject->smk_rules,
 513                                 &rule.smk_subject->smk_rules_lock);
 514                 else
 515                         rc = smk_set_access(&rule, rule_list, rule_lock);
 516
 517                 if (rc)
 518                         goto out;
 519         }
 520
 521         rc = cnt;
 522 out:
 523         kfree(data);
 524         return rc;
 525 }
 526
 527 /*
 528  * Core logic for smackfs seq list operations.
 529  */
 530
 531 static void *smk_seq_start(struct seq_file *s, loff_t *pos,
 532                                 struct list_head *head)
 533 {
 534         struct list_head *list;
 535         int i = *pos;
 536
 537         rcu_read_lock();
 538         for (list = rcu_dereference(list_next_rcu(head));
 539                 list != head;
 540                 list = rcu_dereference(list_next_rcu(list))) {
 541                 if (i-- == 0)
 542                         return list;
 543         }
 544
 545         return NULL;
 546 }
 547
 548 static void *smk_seq_next(struct seq_file *s, void *v, loff_t *pos,
 549                                 struct list_head *head)
 550 {
 551         struct list_head *list = v;
 552
 553         ++*pos;
 554         list = rcu_dereference(list_next_rcu(list));
 555
 556         return (list == head) ? NULL : list;
 557 }
 558
 559 static void smk_seq_stop(struct seq_file *s, void *v)
 560 {
 561         rcu_read_unlock();
 562 }
 563
 564 static void smk_rule_show(struct seq_file *s, struct smack_rule *srp, int max)
 565 {
 566         /*
 567          * Don't show any rules with label names too long for
 568          * interface file (/smack/load or /smack/load2)
 569          * because you should expect to be able to write
 570          * anything you read back.
 571          */
 572         if (strlen(srp->smk_subject->smk_known) >= max ||
 573             strlen(srp->smk_object->smk_known) >= max)
 574                 return;
 575
 576         if (srp->smk_access == 0)
 577                 return;
 578
 579         seq_printf(s, "%s %s",
 580                    srp->smk_subject->smk_known,
 581                    srp->smk_object->smk_known);
 582
 583         seq_putc(s, ' ');
 584
 585         if (srp->smk_access & MAY_READ)
 586                 seq_putc(s, 'r');
 587         if (srp->smk_access & MAY_WRITE)
 588                 seq_putc(s, 'w');
 589         if (srp->smk_access & MAY_EXEC)
 590                 seq_putc(s, 'x');
 591         if (srp->smk_access & MAY_APPEND)
 592                 seq_putc(s, 'a');
 593         if (srp->smk_access & MAY_TRANSMUTE)
 594                 seq_putc(s, 't');
 595         if (srp->smk_access & MAY_LOCK)
 596                 seq_putc(s, 'l');
 597         if (srp->smk_access & MAY_BRINGUP)
 598                 seq_putc(s, 'b');
 599
 600         seq_putc(s, '\n');
 601 }
 602
 603 /*
 604  * Seq_file read operations for /smack/load
 605  */
 606
 607 static void *load2_seq_start(struct seq_file *s, loff_t *pos)
 608 {
 609         return smk_seq_start(s, pos, &smack_known_list);
 610 }
 611
 612 static void *load2_seq_next(struct seq_file *s, void *v, loff_t *pos)
 613 {
 614         return smk_seq_next(s, v, pos, &smack_known_list);
 615 }
 616
 617 static int load_seq_show(struct seq_file *s, void *v)
 618 {
 619         struct list_head *list = v;
 620         struct smack_rule *srp;
 621         struct smack_known *skp =
 622                 list_entry_rcu(list, struct smack_known, list);
 623
 624         list_for_each_entry_rcu(srp, &skp->smk_rules, list)
 625                 smk_rule_show(s, srp, SMK_LABELLEN);
 626
 627         return 0;
 628 }
 629
 630 static const struct seq_operations load_seq_ops = {
 631         .start = load2_seq_start,
 632         .next  = load2_seq_next,
 633         .show  = load_seq_show,
 634         .stop  = smk_seq_stop,
 635 };
 636
 637 /**
 638  * smk_open_load - open() for /smack/load
 639  * @inode: inode structure representing file
 640  * @file: "load" file pointer
 641  *
 642  * For reading, use load_seq_* seq_file reading operations.
 643  */
 644 static int smk_open_load(struct inode *inode, struct file *file)
 645 {
 646         return seq_open(file, &load_seq_ops);
 647 }
 648
 649 /**
 650  * smk_write_load - write() for /smack/load
 651  * @file: file pointer, not actually used
 652  * @buf: where to get the data from
 653  * @count: bytes sent
 654  * @ppos: where to start - must be 0
 655  *
 656  */
 657 static ssize_t smk_write_load(struct file *file, const char __user *buf,
 658                               size_t count, loff_t *ppos)
 659 {
 660         /*
 661          * Must have privilege.
 662          * No partial writes.
 663          * Enough data must be present.
 664          */
 665         if (!smack_privileged(CAP_MAC_ADMIN))
 666                 return -EPERM;
 667
 668         return smk_write_rules_list(file, buf, count, ppos, NULL, NULL,
 669                                     SMK_FIXED24_FMT);
 670 }
 671
 672 static const struct file_operations smk_load_ops = {
 673         .open           = smk_open_load,
 674         .read           = seq_read,
 675         .llseek         = seq_lseek,
 676         .write          = smk_write_load,
 677         .release        = seq_release,
 678 };
 679
 680 /**
 681  * smk_cipso_doi - initialize the CIPSO domain
 682  */
 683 static void smk_cipso_doi(void)
 684 {
 685         int rc;
 686         struct cipso_v4_doi *doip;
 687         struct netlbl_audit nai;
 688
 689         smk_netlabel_audit_set(&nai);
 690
 691         rc = netlbl_cfg_map_del(NULL, PF_INET, NULL, NULL, &nai);
 692         if (rc != 0)
 693                 printk(KERN_WARNING "%s:%d remove rc = %d\n",
 694                        __func__, __LINE__, rc);
 695
 696         doip = kmalloc(sizeof(struct cipso_v4_doi), GFP_KERNEL | __GFP_NOFAIL);
 697         doip->map.std = NULL;
 698         doip->doi = smk_cipso_doi_value;
 699         doip->type = CIPSO_V4_MAP_PASS;
 700         doip->tags[0] = CIPSO_V4_TAG_RBITMAP;
 701         for (rc = 1; rc < CIPSO_V4_TAG_MAXCNT; rc++)
 702                 doip->tags[rc] = CIPSO_V4_TAG_INVALID;
 703
 704         rc = netlbl_cfg_cipsov4_add(doip, &nai);
 705         if (rc != 0) {
 706                 printk(KERN_WARNING "%s:%d cipso add rc = %d\n",
 707                        __func__, __LINE__, rc);
 708                 kfree(doip);
 709                 return;
 710         }
 711         rc = netlbl_cfg_cipsov4_map_add(doip->doi, NULL, NULL, NULL, &nai);
 712         if (rc != 0) {
 713                 printk(KERN_WARNING "%s:%d map add rc = %d\n",
 714                        __func__, __LINE__, rc);
 715                 netlbl_cfg_cipsov4_del(doip->doi, &nai);
 716                 return;
 717         }
 718 }
 719
 720 /**
 721  * smk_unlbl_ambient - initialize the unlabeled domain
 722  * @oldambient: previous domain string
 723  */
 724 static void smk_unlbl_ambient(char *oldambient)
 725 {
 726         int rc;
 727         struct netlbl_audit nai;
 728
 729         smk_netlabel_audit_set(&nai);
 730
 731         if (oldambient != NULL) {
 732                 rc = netlbl_cfg_map_del(oldambient, PF_INET, NULL, NULL, &nai);
 733                 if (rc != 0)
 734                         printk(KERN_WARNING "%s:%d remove rc = %d\n",
 735                                __func__, __LINE__, rc);
 736         }
 737         if (smack_net_ambient == NULL)
 738                 smack_net_ambient = &smack_known_floor;
 739
 740         rc = netlbl_cfg_unlbl_map_add(smack_net_ambient->smk_known, PF_INET,
 741                                       NULL, NULL, &nai);
 742         if (rc != 0)
 743                 printk(KERN_WARNING "%s:%d add rc = %d\n",
 744                        __func__, __LINE__, rc);
 745 }
 746
 747 /*
 748  * Seq_file read operations for /smack/cipso
 749  */
 750
 751 static void *cipso_seq_start(struct seq_file *s, loff_t *pos)
 752 {
 753         return smk_seq_start(s, pos, &smack_known_list);
 754 }
 755
 756 static void *cipso_seq_next(struct seq_file *s, void *v, loff_t *pos)
 757 {
 758         return smk_seq_next(s, v, pos, &smack_known_list);
 759 }
 760
 761 /*
 762  * Print cipso labels in format:
 763  * label level[/cat[,cat]]
 764  */
 765 static int cipso_seq_show(struct seq_file *s, void *v)
 766 {
 767         struct list_head  *list = v;
 768         struct smack_known *skp =
 769                 list_entry_rcu(list, struct smack_known, list);
 770         struct netlbl_lsm_catmap *cmp = skp->smk_netlabel.attr.mls.cat;
 771         char sep = '/';
 772         int i;
 773
 774         /*
 775          * Don't show a label that could not have been set using
 776          * /smack/cipso. This is in support of the notion that
 777          * anything read from /smack/cipso ought to be writeable
 778          * to /smack/cipso.
 779          *
 780          * /smack/cipso2 should be used instead.
 781          */
 782         if (strlen(skp->smk_known) >= SMK_LABELLEN)
 783                 return 0;
 784
 785         seq_printf(s, "%s %3d", skp->smk_known, skp->smk_netlabel.attr.mls.lvl);
 786
 787         for (i = netlbl_catmap_walk(cmp, 0); i >= 0;
 788              i = netlbl_catmap_walk(cmp, i + 1)) {
 789                 seq_printf(s, "%c%d", sep, i);
 790                 sep = ',';
 791         }
 792
 793         seq_putc(s, '\n');
 794
 795         return 0;
 796 }
 797
 798 static const struct seq_operations cipso_seq_ops = {
 799         .start = cipso_seq_start,
 800         .next  = cipso_seq_next,
 801         .show  = cipso_seq_show,
 802         .stop  = smk_seq_stop,
 803 };
 804
 805 /**
 806  * smk_open_cipso - open() for /smack/cipso
 807  * @inode: inode structure representing file
 808  * @file: "cipso" file pointer
 809  *
 810  * Connect our cipso_seq_* operations with /smack/cipso
 811  * file_operations
 812  */
 813 static int smk_open_cipso(struct inode *inode, struct file *file)
 814 {
 815         return seq_open(file, &cipso_seq_ops);
 816 }
 817
 818 /**
 819  * smk_set_cipso - do the work for write() for cipso and cipso2
 820  * @file: file pointer, not actually used
 821  * @buf: where to get the data from
 822  * @count: bytes sent
 823  * @ppos: where to start
 824  * @format: /smack/cipso or /smack/cipso2
 825  *
 826  * Accepts only one cipso rule per write call.
 827  * Returns number of bytes written or error code, as appropriate
 828  */
 829 static ssize_t smk_set_cipso(struct file *file, const char __user *buf,
 830                                 size_t count, loff_t *ppos, int format)
 831 {
 832         struct netlbl_lsm_catmap *old_cat;
 833         struct smack_known *skp;
 834         struct netlbl_lsm_secattr ncats;
 835         char mapcatset[SMK_CIPSOLEN];
 836         int maplevel;
 837         unsigned int cat;
 838         int catlen;
 839         ssize_t rc = -EINVAL;
 840         char *data = NULL;
 841         char *rule;
 842         int ret;
 843         int i;
 844
 845         /*
 846          * Must have privilege.
 847          * No partial writes.
 848          * Enough data must be present.
 849          */
 850         if (!smack_privileged(CAP_MAC_ADMIN))
 851                 return -EPERM;
 852         if (*ppos != 0)
 853                 return -EINVAL;
 854         if (format == SMK_FIXED24_FMT &&
 855             (count < SMK_CIPSOMIN || count > SMK_CIPSOMAX))
 856                 return -EINVAL;
 857         if (count > PAGE_SIZE)
 858                 return -EINVAL;
 859
 860         data = memdup_user_nul(buf, count);
 861         if (IS_ERR(data))
 862                 return PTR_ERR(data);
 863
 864         rule = data;
 865         /*
 866          * Only allow one writer at a time. Writes should be
 867          * quite rare and small in any case.
 868          */
 869         mutex_lock(&smack_cipso_lock);
 870
 871         skp = smk_import_entry(rule, 0);
 872         if (IS_ERR(skp)) {
 873                 rc = PTR_ERR(skp);
 874                 goto out;
 875         }
 876
 877         if (format == SMK_FIXED24_FMT)
 878                 rule += SMK_LABELLEN;
 879         else
 880                 rule += strlen(skp->smk_known) + 1;
 881
 882         if (rule > data + count) {
 883                 rc = -EOVERFLOW;
 884                 goto out;
 885         }
 886
 887         ret = sscanf(rule, "%d", &maplevel);
 888         if (ret != 1 || maplevel < 0 || maplevel > SMACK_CIPSO_MAXLEVEL)
 889                 goto out;
 890
 891         rule += SMK_DIGITLEN;
 892         if (rule > data + count) {
 893                 rc = -EOVERFLOW;
 894                 goto out;
 895         }
 896
 897         ret = sscanf(rule, "%d", &catlen);
 898         if (ret != 1 || catlen > SMACK_CIPSO_MAXCATNUM)
 899                 goto out;
 900
 901         if (format == SMK_FIXED24_FMT &&
 902             count != (SMK_CIPSOMIN + catlen * SMK_DIGITLEN))
 903                 goto out;
 904
 905         memset(mapcatset, 0, sizeof(mapcatset));
 906
 907         for (i = 0; i < catlen; i++) {
 908                 rule += SMK_DIGITLEN;
 909                 if (rule > data + count) {
 910                         rc = -EOVERFLOW;
 911                         goto out;
 912                 }
 913                 ret = sscanf(rule, "%u", &cat);
 914                 if (ret != 1 || cat > SMACK_CIPSO_MAXCATNUM)
 915                         goto out;
 916
 917                 smack_catset_bit(cat, mapcatset);
 918         }
 919
 920         rc = smk_netlbl_mls(maplevel, mapcatset, &ncats, SMK_CIPSOLEN);
 921         if (rc >= 0) {
 922                 old_cat = skp->smk_netlabel.attr.mls.cat;
 923                 skp->smk_netlabel.attr.mls.cat = ncats.attr.mls.cat;
 924                 skp->smk_netlabel.attr.mls.lvl = ncats.attr.mls.lvl;
 925                 synchronize_rcu();
 926                 netlbl_catmap_free(old_cat);
 927                 rc = count;
 928         }
 929
 930 out:
 931         mutex_unlock(&smack_cipso_lock);
 932         kfree(data);
 933         return rc;
 934 }
 935
 936 /**
 937  * smk_write_cipso - write() for /smack/cipso
 938  * @file: file pointer, not actually used
 939  * @buf: where to get the data from
 940  * @count: bytes sent
 941  * @ppos: where to start
 942  *
 943  * Accepts only one cipso rule per write call.
 944  * Returns number of bytes written or error code, as appropriate
 945  */
 946 static ssize_t smk_write_cipso(struct file *file, const char __user *buf,
 947                                size_t count, loff_t *ppos)
 948 {
 949         return smk_set_cipso(file, buf, count, ppos, SMK_FIXED24_FMT);
 950 }
 951
 952 static const struct file_operations smk_cipso_ops = {
 953         .open           = smk_open_cipso,
 954         .read           = seq_read,
 955         .llseek         = seq_lseek,
 956         .write          = smk_write_cipso,
 957         .release        = seq_release,
 958 };
 959
 960 /*
 961  * Seq_file read operations for /smack/cipso2
 962  */
 963
 964 /*
 965  * Print cipso labels in format:
 966  * label level[/cat[,cat]]
 967  */
 968 static int cipso2_seq_show(struct seq_file *s, void *v)
 969 {
 970         struct list_head  *list = v;
 971         struct smack_known *skp =
 972                 list_entry_rcu(list, struct smack_known, list);
 973         struct netlbl_lsm_catmap *cmp = skp->smk_netlabel.attr.mls.cat;
 974         char sep = '/';
 975         int i;
 976
 977         seq_printf(s, "%s %3d", skp->smk_known, skp->smk_netlabel.attr.mls.lvl);
 978
 979         for (i = netlbl_catmap_walk(cmp, 0); i >= 0;
 980              i = netlbl_catmap_walk(cmp, i + 1)) {
 981                 seq_printf(s, "%c%d", sep, i);
 982                 sep = ',';
 983         }
 984
 985         seq_putc(s, '\n');
 986
 987         return 0;
 988 }
 989
 990 static const struct seq_operations cipso2_seq_ops = {
 991         .start = cipso_seq_start,
 992         .next  = cipso_seq_next,
 993         .show  = cipso2_seq_show,
 994         .stop  = smk_seq_stop,
 995 };
 996
 997 /**
 998  * smk_open_cipso2 - open() for /smack/cipso2
 999  * @inode: inode structure representing file
1000  * @file: "cipso2" file pointer
1001  *
1002  * Connect our cipso_seq_* operations with /smack/cipso2
1003  * file_operations
1004  */
1005 static int smk_open_cipso2(struct inode *inode, struct file *file)
1006 {
1007         return seq_open(file, &cipso2_seq_ops);
1008 }
1009
1010 /**
1011  * smk_write_cipso2 - write() for /smack/cipso2
1012  * @file: file pointer, not actually used
1013  * @buf: where to get the data from
1014  * @count: bytes sent
1015  * @ppos: where to start
1016  *
1017  * Accepts only one cipso rule per write call.
1018  * Returns number of bytes written or error code, as appropriate
1019  */
1020 static ssize_t smk_write_cipso2(struct file *file, const char __user *buf,
1021                               size_t count, loff_t *ppos)
1022 {
1023         return smk_set_cipso(file, buf, count, ppos, SMK_LONG_FMT);
1024 }
1025
1026 static const struct file_operations smk_cipso2_ops = {
1027         .open           = smk_open_cipso2,
1028         .read           = seq_read,
1029         .llseek         = seq_lseek,
1030         .write          = smk_write_cipso2,
1031         .release        = seq_release,
1032 };
1033
1034 /*
1035  * Seq_file read operations for /smack/netlabel
1036  */
1037
1038 static void *net4addr_seq_start(struct seq_file *s, loff_t *pos)
1039 {
1040         return smk_seq_start(s, pos, &smk_net4addr_list);
1041 }
1042
1043 static void *net4addr_seq_next(struct seq_file *s, void *v, loff_t *pos)
1044 {
1045         return smk_seq_next(s, v, pos, &smk_net4addr_list);
1046 }
1047
1048 /*
1049  * Print host/label pairs
1050  */
1051 static int net4addr_seq_show(struct seq_file *s, void *v)
1052 {
1053         struct list_head *list = v;
1054         struct smk_net4addr *skp =
1055                         list_entry_rcu(list, struct smk_net4addr, list);
1056         char *kp = SMACK_CIPSO_OPTION;
1057
1058         if (skp->smk_label != NULL)
1059                 kp = skp->smk_label->smk_known;
1060         seq_printf(s, "%pI4/%d %s\n", &skp->smk_host.s_addr,
1061                         skp->smk_masks, kp);
1062
1063         return 0;
1064 }
1065
1066 static const struct seq_operations net4addr_seq_ops = {
1067         .start = net4addr_seq_start,
1068         .next  = net4addr_seq_next,
1069         .show  = net4addr_seq_show,
1070         .stop  = smk_seq_stop,
1071 };
1072
1073 /**
1074  * smk_open_net4addr - open() for /smack/netlabel
1075  * @inode: inode structure representing file
1076  * @file: "netlabel" file pointer
1077  *
1078  * Connect our net4addr_seq_* operations with /smack/netlabel
1079  * file_operations
1080  */
1081 static int smk_open_net4addr(struct inode *inode, struct file *file)
1082 {
1083         return seq_open(file, &net4addr_seq_ops);
1084 }
1085
1086 /**
1087  * smk_net4addr_insert
1088  * @new : netlabel to insert
1089  *
1090  * This helper insert netlabel in the smack_net4addrs list
1091  * sorted by netmask length (longest to smallest)
1092  * locked by &smk_net4addr_lock in smk_write_net4addr
1093  *
1094  */
1095 static void smk_net4addr_insert(struct smk_net4addr *new)
1096 {
1097         struct smk_net4addr *m;
1098         struct smk_net4addr *m_next;
1099
1100         if (list_empty(&smk_net4addr_list)) {
1101                 list_add_rcu(&new->list, &smk_net4addr_list);
1102                 return;
1103         }
1104
1105         m = list_entry_rcu(smk_net4addr_list.next,
1106                            struct smk_net4addr, list);
1107
1108         /* the comparison '>' is a bit hacky, but works */
1109         if (new->smk_masks > m->smk_masks) {
1110                 list_add_rcu(&new->list, &smk_net4addr_list);
1111                 return;
1112         }
1113
1114         list_for_each_entry_rcu(m, &smk_net4addr_list, list) {
1115                 if (list_is_last(&m->list, &smk_net4addr_list)) {
1116                         list_add_rcu(&new->list, &m->list);
1117                         return;
1118                 }
1119                 m_next = list_entry_rcu(m->list.next,
1120                                         struct smk_net4addr, list);
1121                 if (new->smk_masks > m_next->smk_masks) {
1122                         list_add_rcu(&new->list, &m->list);
1123                         return;
1124                 }
1125         }
1126 }
1127
1128
1129 /**
1130  * smk_write_net4addr - write() for /smack/netlabel
1131  * @file: file pointer, not actually used
1132  * @buf: where to get the data from
1133  * @count: bytes sent
1134  * @ppos: where to start
1135  *
1136  * Accepts only one net4addr per write call.
1137  * Returns number of bytes written or error code, as appropriate
1138  */
1139 static ssize_t smk_write_net4addr(struct file *file, const char __user *buf,
1140                                 size_t count, loff_t *ppos)
1141 {
1142         struct smk_net4addr *snp;
1143         struct sockaddr_in newname;
1144         char *smack;
1145         struct smack_known *skp = NULL;
1146         char *data;
1147         char *host = (char *)&newname.sin_addr.s_addr;
1148         int rc;
1149         struct netlbl_audit audit_info;
1150         struct in_addr mask;
1151         unsigned int m;
1152         unsigned int masks;
1153         int found;
1154         u32 mask_bits = (1<<31);
1155         __be32 nsa;
1156         u32 temp_mask;
1157
1158         /*
1159          * Must have privilege.
1160          * No partial writes.
1161          * Enough data must be present.
1162          * "<addr/mask, as a.b.c.d/e><space><label>"
1163          * "<addr, as a.b.c.d><space><label>"
1164          */
1165         if (!smack_privileged(CAP_MAC_ADMIN))
1166                 return -EPERM;
1167         if (*ppos != 0)
1168                 return -EINVAL;
1169         if (count < SMK_NETLBLADDRMIN || count > PAGE_SIZE - 1)
1170                 return -EINVAL;
1171
1172         data = memdup_user_nul(buf, count);
1173         if (IS_ERR(data))
1174                 return PTR_ERR(data);
1175
1176         smack = kzalloc(count + 1, GFP_KERNEL);
1177         if (smack == NULL) {
1178                 rc = -ENOMEM;
1179                 goto free_data_out;
1180         }
1181
1182         rc = sscanf(data, "%hhd.%hhd.%hhd.%hhd/%u %s",
1183                 &host[0], &host[1], &host[2], &host[3], &masks, smack);
1184         if (rc != 6) {
1185                 rc = sscanf(data, "%hhd.%hhd.%hhd.%hhd %s",
1186                         &host[0], &host[1], &host[2], &host[3], smack);
1187                 if (rc != 5) {
1188                         rc = -EINVAL;
1189                         goto free_out;
1190                 }
1191                 m = BEBITS;
1192                 masks = 32;
1193         }
1194         if (masks > BEBITS) {
1195                 rc = -EINVAL;
1196                 goto free_out;
1197         }
1198
1199         /*
1200          * If smack begins with '-', it is an option, don't import it
1201          */
1202         if (smack[0] != '-') {
1203                 skp = smk_import_entry(smack, 0);
1204                 if (IS_ERR(skp)) {
1205                         rc = PTR_ERR(skp);
1206                         goto free_out;
1207                 }
1208         } else {
1209                 /*
1210                  * Only the -CIPSO option is supported for IPv4
1211                  */
1212                 if (strcmp(smack, SMACK_CIPSO_OPTION) != 0) {
1213                         rc = -EINVAL;
1214                         goto free_out;
1215                 }
1216         }
1217
1218         for (m = masks, temp_mask = 0; m > 0; m--) {
1219                 temp_mask |= mask_bits;
1220                 mask_bits >>= 1;
1221         }
1222         mask.s_addr = cpu_to_be32(temp_mask);
1223
1224         newname.sin_addr.s_addr &= mask.s_addr;
1225         /*
1226          * Only allow one writer at a time. Writes should be
1227          * quite rare and small in any case.
1228          */
1229         mutex_lock(&smk_net4addr_lock);
1230
1231         nsa = newname.sin_addr.s_addr;
1232         /* try to find if the prefix is already in the list */
1233         found = 0;
1234         list_for_each_entry_rcu(snp, &smk_net4addr_list, list) {
1235                 if (snp->smk_host.s_addr == nsa && snp->smk_masks == masks) {
1236                         found = 1;
1237                         break;
1238                 }
1239         }
1240         smk_netlabel_audit_set(&audit_info);
1241
1242         if (found == 0) {
1243                 snp = kzalloc(sizeof(*snp), GFP_KERNEL);
1244                 if (snp == NULL)
1245                         rc = -ENOMEM;
1246                 else {
1247                         rc = 0;
1248                         snp->smk_host.s_addr = newname.sin_addr.s_addr;
1249                         snp->smk_mask.s_addr = mask.s_addr;
1250                         snp->smk_label = skp;
1251                         snp->smk_masks = masks;
1252                         smk_net4addr_insert(snp);
1253                 }
1254         } else {
1255                 /*
1256                  * Delete the unlabeled entry, only if the previous label
1257                  * wasn't the special CIPSO option
1258                  */
1259                 if (snp->smk_label != NULL)
1260                         rc = netlbl_cfg_unlbl_static_del(&init_net, NULL,
1261                                         &snp->smk_host, &snp->smk_mask,
1262                                         PF_INET, &audit_info);
1263                 else
1264                         rc = 0;
1265                 snp->smk_label = skp;
1266         }
1267
1268         /*
1269          * Now tell netlabel about the single label nature of
1270          * this host so that incoming packets get labeled.
1271          * but only if we didn't get the special CIPSO option
1272          */
1273         if (rc == 0 && skp != NULL)
1274                 rc = netlbl_cfg_unlbl_static_add(&init_net, NULL,
1275                         &snp->smk_host, &snp->smk_mask, PF_INET,
1276                         snp->smk_label->smk_secid, &audit_info);
1277
1278         if (rc == 0)
1279                 rc = count;
1280
1281         mutex_unlock(&smk_net4addr_lock);
1282
1283 free_out:
1284         kfree(smack);
1285 free_data_out:
1286         kfree(data);
1287
1288         return rc;
1289 }
1290
1291 static const struct file_operations smk_net4addr_ops = {
1292         .open           = smk_open_net4addr,
1293         .read           = seq_read,
1294         .llseek         = seq_lseek,
1295         .write          = smk_write_net4addr,
1296         .release        = seq_release,
1297 };
1298
1299 #if IS_ENABLED(CONFIG_IPV6)
1300 /*
1301  * Seq_file read operations for /smack/netlabel6
1302  */
1303
1304 static void *net6addr_seq_start(struct seq_file *s, loff_t *pos)
1305 {
1306         return smk_seq_start(s, pos, &smk_net6addr_list);
1307 }
1308
1309 static void *net6addr_seq_next(struct seq_file *s, void *v, loff_t *pos)
1310 {
1311         return smk_seq_next(s, v, pos, &smk_net6addr_list);
1312 }
1313
1314 /*
1315  * Print host/label pairs
1316  */
1317 static int net6addr_seq_show(struct seq_file *s, void *v)
1318 {
1319         struct list_head *list = v;
1320         struct smk_net6addr *skp =
1321                          list_entry(list, struct smk_net6addr, list);
1322
1323         if (skp->smk_label != NULL)
1324                 seq_printf(s, "%pI6/%d %s\n", &skp->smk_host, skp->smk_masks,
1325                                 skp->smk_label->smk_known);
1326
1327         return 0;
1328 }
1329
1330 static const struct seq_operations net6addr_seq_ops = {
1331         .start = net6addr_seq_start,
1332         .next  = net6addr_seq_next,
1333         .show  = net6addr_seq_show,
1334         .stop  = smk_seq_stop,
1335 };
1336
1337 /**
1338  * smk_open_net6addr - open() for /smack/netlabel
1339  * @inode: inode structure representing file
1340  * @file: "netlabel" file pointer
1341  *
1342  * Connect our net6addr_seq_* operations with /smack/netlabel
1343  * file_operations
1344  */
1345 static int smk_open_net6addr(struct inode *inode, struct file *file)
1346 {
1347         return seq_open(file, &net6addr_seq_ops);
1348 }
1349
1350 /**
1351  * smk_net6addr_insert
1352  * @new : entry to insert
1353  *
1354  * This inserts an entry in the smack_net6addrs list
1355  * sorted by netmask length (longest to smallest)
1356  * locked by &smk_net6addr_lock in smk_write_net6addr
1357  *
1358  */
1359 static void smk_net6addr_insert(struct smk_net6addr *new)
1360 {
1361         struct smk_net6addr *m_next;
1362         struct smk_net6addr *m;
1363
1364         if (list_empty(&smk_net6addr_list)) {
1365                 list_add_rcu(&new->list, &smk_net6addr_list);
1366                 return;
1367         }
1368
1369         m = list_entry_rcu(smk_net6addr_list.next,
1370                            struct smk_net6addr, list);
1371
1372         if (new->smk_masks > m->smk_masks) {
1373                 list_add_rcu(&new->list, &smk_net6addr_list);
1374                 return;
1375         }
1376
1377         list_for_each_entry_rcu(m, &smk_net6addr_list, list) {
1378                 if (list_is_last(&m->list, &smk_net6addr_list)) {
1379                         list_add_rcu(&new->list, &m->list);
1380                         return;
1381                 }
1382                 m_next = list_entry_rcu(m->list.next,
1383                                         struct smk_net6addr, list);
1384                 if (new->smk_masks > m_next->smk_masks) {
1385                         list_add_rcu(&new->list, &m->list);
1386                         return;
1387                 }
1388         }
1389 }
1390
1391
1392 /**
1393  * smk_write_net6addr - write() for /smack/netlabel
1394  * @file: file pointer, not actually used
1395  * @buf: where to get the data from
1396  * @count: bytes sent
1397  * @ppos: where to start
1398  *
1399  * Accepts only one net6addr per write call.
1400  * Returns number of bytes written or error code, as appropriate
1401  */
1402 static ssize_t smk_write_net6addr(struct file *file, const char __user *buf,
1403                                 size_t count, loff_t *ppos)
1404 {
1405         struct smk_net6addr *snp;
1406         struct in6_addr newname;
1407         struct in6_addr fullmask;
1408         struct smack_known *skp = NULL;
1409         char *smack;
1410         char *data;
1411         int rc = 0;
1412         int found = 0;
1413         int i;
1414         unsigned int scanned[8];
1415         unsigned int m;
1416         unsigned int mask = 128;
1417
1418         /*
1419          * Must have privilege.
1420          * No partial writes.
1421          * Enough data must be present.
1422          * "<addr/mask, as a:b:c:d:e:f:g:h/e><space><label>"
1423          * "<addr, as a:b:c:d:e:f:g:h><space><label>"
1424          */
1425         if (!smack_privileged(CAP_MAC_ADMIN))
1426                 return -EPERM;
1427         if (*ppos != 0)
1428                 return -EINVAL;
1429         if (count < SMK_NETLBLADDRMIN || count > PAGE_SIZE - 1)
1430                 return -EINVAL;
1431
1432         data = memdup_user_nul(buf, count);
1433         if (IS_ERR(data))
1434                 return PTR_ERR(data);
1435
1436         smack = kzalloc(count + 1, GFP_KERNEL);
1437         if (smack == NULL) {
1438                 rc = -ENOMEM;
1439                 goto free_data_out;
1440         }
1441
1442         i = sscanf(data, "%x:%x:%x:%x:%x:%x:%x:%x/%u %s",
1443                         &scanned[0], &scanned[1], &scanned[2], &scanned[3],
1444                         &scanned[4], &scanned[5], &scanned[6], &scanned[7],
1445                         &mask, smack);
1446         if (i != 10) {
1447                 i = sscanf(data, "%x:%x:%x:%x:%x:%x:%x:%x %s",
1448                                 &scanned[0], &scanned[1], &scanned[2],
1449                                 &scanned[3], &scanned[4], &scanned[5],
1450                                 &scanned[6], &scanned[7], smack);
1451                 if (i != 9) {
1452                         rc = -EINVAL;
1453                         goto free_out;
1454                 }
1455         }
1456         if (mask > 128) {
1457                 rc = -EINVAL;
1458                 goto free_out;
1459         }
1460         for (i = 0; i < 8; i++) {
1461                 if (scanned[i] > 0xffff) {
1462                         rc = -EINVAL;
1463                         goto free_out;
1464                 }
1465                 newname.s6_addr16[i] = htons(scanned[i]);
1466         }
1467
1468         /*
1469          * If smack begins with '-', it is an option, don't import it
1470          */
1471         if (smack[0] != '-') {
1472                 skp = smk_import_entry(smack, 0);
1473                 if (IS_ERR(skp)) {
1474                         rc = PTR_ERR(skp);
1475                         goto free_out;
1476                 }
1477         } else {
1478                 /*
1479                  * Only -DELETE is supported for IPv6
1480                  */
1481                 if (strcmp(smack, SMACK_DELETE_OPTION) != 0) {
1482                         rc = -EINVAL;
1483                         goto free_out;
1484                 }
1485         }
1486
1487         for (i = 0, m = mask; i < 8; i++) {
1488                 if (m >= 16) {
1489                         fullmask.s6_addr16[i] = 0xffff;
1490                         m -= 16;
1491                 } else if (m > 0) {
1492                         fullmask.s6_addr16[i] = (1 << m) - 1;
1493                         m = 0;
1494                 } else
1495                         fullmask.s6_addr16[i] = 0;
1496                 newname.s6_addr16[i] &= fullmask.s6_addr16[i];
1497         }
1498
1499         /*
1500          * Only allow one writer at a time. Writes should be
1501          * quite rare and small in any case.
1502          */
1503         mutex_lock(&smk_net6addr_lock);
1504         /*
1505          * Try to find the prefix in the list
1506          */
1507         list_for_each_entry_rcu(snp, &smk_net6addr_list, list) {
1508                 if (mask != snp->smk_masks)
1509                         continue;
1510                 for (found = 1, i = 0; i < 8; i++) {
1511                         if (newname.s6_addr16[i] !=
1512                             snp->smk_host.s6_addr16[i]) {
1513                                 found = 0;
1514                                 break;
1515                         }
1516                 }
1517                 if (found == 1)
1518                         break;
1519         }
1520         if (found == 0) {
1521                 snp = kzalloc(sizeof(*snp), GFP_KERNEL);
1522                 if (snp == NULL)
1523                         rc = -ENOMEM;
1524                 else {
1525                         snp->smk_host = newname;
1526                         snp->smk_mask = fullmask;
1527                         snp->smk_masks = mask;
1528                         snp->smk_label = skp;
1529                         smk_net6addr_insert(snp);
1530                 }
1531         } else {
1532                 snp->smk_label = skp;
1533         }
1534
1535         if (rc == 0)
1536                 rc = count;
1537
1538         mutex_unlock(&smk_net6addr_lock);
1539
1540 free_out:
1541         kfree(smack);
1542 free_data_out:
1543         kfree(data);
1544
1545         return rc;
1546 }
1547
1548 static const struct file_operations smk_net6addr_ops = {
1549         .open           = smk_open_net6addr,
1550         .read           = seq_read,
1551         .llseek         = seq_lseek,
1552         .write          = smk_write_net6addr,
1553         .release        = seq_release,
1554 };
1555 #endif /* CONFIG_IPV6 */
1556
1557 /**
1558  * smk_read_doi - read() for /smack/doi
1559  * @filp: file pointer, not actually used
1560  * @buf: where to put the result
1561  * @count: maximum to send along
1562  * @ppos: where to start
1563  *
1564  * Returns number of bytes read or error code, as appropriate
1565  */
1566 static ssize_t smk_read_doi(struct file *filp, char __user *buf,
1567                             size_t count, loff_t *ppos)
1568 {
1569         char temp[80];
1570         ssize_t rc;
1571
1572         if (*ppos != 0)
1573                 return 0;
1574
1575         sprintf(temp, "%d", smk_cipso_doi_value);
1576         rc = simple_read_from_buffer(buf, count, ppos, temp, strlen(temp));
1577
1578         return rc;
1579 }
1580
1581 /**
1582  * smk_write_doi - write() for /smack/doi
1583  * @file: file pointer, not actually used
1584  * @buf: where to get the data from
1585  * @count: bytes sent
1586  * @ppos: where to start
1587  *
1588  * Returns number of bytes written or error code, as appropriate
1589  */
1590 static ssize_t smk_write_doi(struct file *file, const char __user *buf,
1591                              size_t count, loff_t *ppos)
1592 {
1593         char temp[80];
1594         int i;
1595
1596         if (!smack_privileged(CAP_MAC_ADMIN))
1597                 return -EPERM;
1598
1599         if (count >= sizeof(temp) || count == 0)
1600                 return -EINVAL;
1601
1602         if (copy_from_user(temp, buf, count) != 0)
1603                 return -EFAULT;
1604
1605         temp[count] = '\0';
1606
1607         if (sscanf(temp, "%d", &i) != 1)
1608                 return -EINVAL;
1609
1610         smk_cipso_doi_value = i;
1611
1612         smk_cipso_doi();
1613
1614         return count;
1615 }
1616
1617 static const struct file_operations smk_doi_ops = {
1618         .read           = smk_read_doi,
1619         .write          = smk_write_doi,
1620         .llseek         = default_llseek,
1621 };
1622
1623 /**
1624  * smk_read_direct - read() for /smack/direct
1625  * @filp: file pointer, not actually used
1626  * @buf: where to put the result
1627  * @count: maximum to send along
1628  * @ppos: where to start
1629  *
1630  * Returns number of bytes read or error code, as appropriate
1631  */
1632 static ssize_t smk_read_direct(struct file *filp, char __user *buf,
1633                                size_t count, loff_t *ppos)
1634 {
1635         char temp[80];
1636         ssize_t rc;
1637
1638         if (*ppos != 0)
1639                 return 0;
1640
1641         sprintf(temp, "%d", smack_cipso_direct);
1642         rc = simple_read_from_buffer(buf, count, ppos, temp, strlen(temp));
1643
1644         return rc;
1645 }
1646
1647 /**
1648  * smk_write_direct - write() for /smack/direct
1649  * @file: file pointer, not actually used
1650  * @buf: where to get the data from
1651  * @count: bytes sent
1652  * @ppos: where to start
1653  *
1654  * Returns number of bytes written or error code, as appropriate
1655  */
1656 static ssize_t smk_write_direct(struct file *file, const char __user *buf,
1657                                 size_t count, loff_t *ppos)
1658 {
1659         struct smack_known *skp;
1660         char temp[80];
1661         int i;
1662
1663         if (!smack_privileged(CAP_MAC_ADMIN))
1664                 return -EPERM;
1665
1666         if (count >= sizeof(temp) || count == 0)
1667                 return -EINVAL;
1668
1669         if (copy_from_user(temp, buf, count) != 0)
1670                 return -EFAULT;
1671
1672         temp[count] = '\0';
1673
1674         if (sscanf(temp, "%d", &i) != 1)
1675                 return -EINVAL;
1676
1677         /*
1678          * Don't do anything if the value hasn't actually changed.
1679          * If it is changing reset the level on entries that were
1680          * set up to be direct when they were created.
1681          */
1682         if (smack_cipso_direct != i) {
1683                 mutex_lock(&smack_known_lock);
1684                 list_for_each_entry_rcu(skp, &smack_known_list, list)
1685                         if (skp->smk_netlabel.attr.mls.lvl ==
1686                             smack_cipso_direct)
1687                                 skp->smk_netlabel.attr.mls.lvl = i;
1688                 smack_cipso_direct = i;
1689                 mutex_unlock(&smack_known_lock);
1690         }
1691
1692         return count;
1693 }
1694
1695 static const struct file_operations smk_direct_ops = {
1696         .read           = smk_read_direct,
1697         .write          = smk_write_direct,
1698         .llseek         = default_llseek,
1699 };
1700
1701 /**
1702  * smk_read_mapped - read() for /smack/mapped
1703  * @filp: file pointer, not actually used
1704  * @buf: where to put the result
1705  * @count: maximum to send along
1706  * @ppos: where to start
1707  *
1708  * Returns number of bytes read or error code, as appropriate
1709  */
1710 static ssize_t smk_read_mapped(struct file *filp, char __user *buf,
1711                                size_t count, loff_t *ppos)
1712 {
1713         char temp[80];
1714         ssize_t rc;
1715
1716         if (*ppos != 0)
1717                 return 0;
1718
1719         sprintf(temp, "%d", smack_cipso_mapped);
1720         rc = simple_read_from_buffer(buf, count, ppos, temp, strlen(temp));
1721
1722         return rc;
1723 }
1724
1725 /**
1726  * smk_write_mapped - write() for /smack/mapped
1727  * @file: file pointer, not actually used
1728  * @buf: where to get the data from
1729  * @count: bytes sent
1730  * @ppos: where to start
1731  *
1732  * Returns number of bytes written or error code, as appropriate
1733  */
1734 static ssize_t smk_write_mapped(struct file *file, const char __user *buf,
1735                                 size_t count, loff_t *ppos)
1736 {
1737         struct smack_known *skp;
1738         char temp[80];
1739         int i;
1740
1741         if (!smack_privileged(CAP_MAC_ADMIN))
1742                 return -EPERM;
1743
1744         if (count >= sizeof(temp) || count == 0)
1745                 return -EINVAL;
1746
1747         if (copy_from_user(temp, buf, count) != 0)
1748                 return -EFAULT;
1749
1750         temp[count] = '\0';
1751
1752         if (sscanf(temp, "%d", &i) != 1)
1753                 return -EINVAL;
1754
1755         /*
1756          * Don't do anything if the value hasn't actually changed.
1757          * If it is changing reset the level on entries that were
1758          * set up to be mapped when they were created.
1759          */
1760         if (smack_cipso_mapped != i) {
1761                 mutex_lock(&smack_known_lock);
1762                 list_for_each_entry_rcu(skp, &smack_known_list, list)
1763                         if (skp->smk_netlabel.attr.mls.lvl ==
1764                             smack_cipso_mapped)
1765                                 skp->smk_netlabel.attr.mls.lvl = i;
1766                 smack_cipso_mapped = i;
1767                 mutex_unlock(&smack_known_lock);
1768         }
1769
1770         return count;
1771 }
1772
1773 static const struct file_operations smk_mapped_ops = {
1774         .read           = smk_read_mapped,
1775         .write          = smk_write_mapped,
1776         .llseek         = default_llseek,
1777 };
1778
1779 /**
1780  * smk_read_ambient - read() for /smack/ambient
1781  * @filp: file pointer, not actually used
1782  * @buf: where to put the result
1783  * @cn: maximum to send along
1784  * @ppos: where to start
1785  *
1786  * Returns number of bytes read or error code, as appropriate
1787  */
1788 static ssize_t smk_read_ambient(struct file *filp, char __user *buf,
1789                                 size_t cn, loff_t *ppos)
1790 {
1791         ssize_t rc;
1792         int asize;
1793
1794         if (*ppos != 0)
1795                 return 0;
1796         /*
1797          * Being careful to avoid a problem in the case where
1798          * smack_net_ambient gets changed in midstream.
1799          */
1800         mutex_lock(&smack_ambient_lock);
1801
1802         asize = strlen(smack_net_ambient->smk_known) + 1;
1803
1804         if (cn >= asize)
1805                 rc = simple_read_from_buffer(buf, cn, ppos,
1806                                              smack_net_ambient->smk_known,
1807                                              asize);
1808         else
1809                 rc = -EINVAL;
1810
1811         mutex_unlock(&smack_ambient_lock);
1812
1813         return rc;
1814 }
1815
1816 /**
1817  * smk_write_ambient - write() for /smack/ambient
1818  * @file: file pointer, not actually used
1819  * @buf: where to get the data from
1820  * @count: bytes sent
1821  * @ppos: where to start
1822  *
1823  * Returns number of bytes written or error code, as appropriate
1824  */
1825 static ssize_t smk_write_ambient(struct file *file, const char __user *buf,
1826                                  size_t count, loff_t *ppos)
1827 {
1828         struct smack_known *skp;
1829         char *oldambient;
1830         char *data;
1831         int rc = count;
1832
1833         if (!smack_privileged(CAP_MAC_ADMIN))
1834                 return -EPERM;
1835
1836         /* Enough data must be present */
1837         if (count == 0 || count > PAGE_SIZE)
1838                 return -EINVAL;
1839
1840         data = memdup_user_nul(buf, count);
1841         if (IS_ERR(data))
1842                 return PTR_ERR(data);
1843
1844         skp = smk_import_entry(data, count);
1845         if (IS_ERR(skp)) {
1846                 rc = PTR_ERR(skp);
1847                 goto out;
1848         }
1849
1850         mutex_lock(&smack_ambient_lock);
1851
1852         oldambient = smack_net_ambient->smk_known;
1853         smack_net_ambient = skp;
1854         smk_unlbl_ambient(oldambient);
1855
1856         mutex_unlock(&smack_ambient_lock);
1857
1858 out:
1859         kfree(data);
1860         return rc;
1861 }
1862
1863 static const struct file_operations smk_ambient_ops = {
1864         .read           = smk_read_ambient,
1865         .write          = smk_write_ambient,
1866         .llseek         = default_llseek,
1867 };
1868
1869 /*
1870  * Seq_file operations for /smack/onlycap
1871  */
1872 static void *onlycap_seq_start(struct seq_file *s, loff_t *pos)
1873 {
1874         return smk_seq_start(s, pos, &smack_onlycap_list);
1875 }
1876
1877 static void *onlycap_seq_next(struct seq_file *s, void *v, loff_t *pos)
1878 {
1879         return smk_seq_next(s, v, pos, &smack_onlycap_list);
1880 }
1881
1882 static int onlycap_seq_show(struct seq_file *s, void *v)
1883 {
1884         struct list_head *list = v;
1885         struct smack_known_list_elem *sklep =
1886                 list_entry_rcu(list, struct smack_known_list_elem, list);
1887
1888         seq_puts(s, sklep->smk_label->smk_known);
1889         seq_putc(s, ' ');
1890
1891         return 0;
1892 }
1893
1894 static const struct seq_operations onlycap_seq_ops = {
1895         .start = onlycap_seq_start,
1896         .next  = onlycap_seq_next,
1897         .show  = onlycap_seq_show,
1898         .stop  = smk_seq_stop,
1899 };
1900
1901 static int smk_open_onlycap(struct inode *inode, struct file *file)
1902 {
1903         return seq_open(file, &onlycap_seq_ops);
1904 }
1905
1906 /**
1907  * smk_list_swap_rcu - swap public list with a private one in RCU-safe way
1908  * The caller must hold appropriate mutex to prevent concurrent modifications
1909  * to the public list.
1910  * Private list is assumed to be not accessible to other threads yet.
1911  *
1912  * @public: public list
1913  * @private: private list
1914  */
1915 static void smk_list_swap_rcu(struct list_head *public,
1916                               struct list_head *private)
1917 {
1918         struct list_head *first, *last;
1919
1920         if (list_empty(public)) {
1921                 list_splice_init_rcu(private, public, synchronize_rcu);
1922         } else {
1923                 /* Remember public list before replacing it */
1924                 first = public->next;
1925                 last = public->prev;
1926
1927                 /* Publish private list in place of public in RCU-safe way */
1928                 private->prev->next = public;
1929                 private->next->prev = public;
1930                 rcu_assign_pointer(public->next, private->next);
1931                 public->prev = private->prev;
1932
1933                 synchronize_rcu();
1934
1935                 /* When all readers are done with the old public list,
1936                  * attach it in place of private */
1937                 private->next = first;
1938                 private->prev = last;
1939                 first->prev = private;
1940                 last->next = private;
1941         }
1942 }
1943
1944 /**
1945  * smk_parse_label_list - parse list of Smack labels, separated by spaces
1946  *
1947  * @data: the string to parse
1948  * @private: destination list
1949  *
1950  * Returns zero on success or error code, as appropriate
1951  */
1952 static int smk_parse_label_list(char *data, struct list_head *list)
1953 {
1954         char *tok;
1955         struct smack_known *skp;
1956         struct smack_known_list_elem *sklep;
1957
1958         while ((tok = strsep(&data, " ")) != NULL) {
1959                 if (!*tok)
1960                         continue;
1961
1962                 skp = smk_import_entry(tok, 0);
1963                 if (IS_ERR(skp))
1964                         return PTR_ERR(skp);
1965
1966                 sklep = kzalloc(sizeof(*sklep), GFP_KERNEL);
1967                 if (sklep == NULL)
1968                         return -ENOMEM;
1969
1970                 sklep->smk_label = skp;
1971                 list_add(&sklep->list, list);
1972         }
1973
1974         return 0;
1975 }
1976
1977 /**
1978  * smk_destroy_label_list - destroy a list of smack_known_list_elem
1979  * @head: header pointer of the list to destroy
1980  */
1981 void smk_destroy_label_list(struct list_head *list)
1982 {
1983         struct smack_known_list_elem *sklep;
1984         struct smack_known_list_elem *sklep2;
1985
1986         list_for_each_entry_safe(sklep, sklep2, list, list)
1987                 kfree(sklep);
1988
1989         INIT_LIST_HEAD(list);
1990 }
1991
1992 /**
1993  * smk_write_onlycap - write() for smackfs/onlycap
1994  * @file: file pointer, not actually used
1995  * @buf: where to get the data from
1996  * @count: bytes sent
1997  * @ppos: where to start
1998  *
1999  * Returns number of bytes written or error code, as appropriate
2000  */
2001 static ssize_t smk_write_onlycap(struct file *file, const char __user *buf,
2002                                  size_t count, loff_t *ppos)
2003 {
2004         char *data;
2005         LIST_HEAD(list_tmp);
2006         int rc;
2007
2008         if (!smack_privileged(CAP_MAC_ADMIN))
2009                 return -EPERM;
2010
2011         if (count > PAGE_SIZE)
2012                 return -EINVAL;
2013
2014         data = memdup_user_nul(buf, count);
2015         if (IS_ERR(data))
2016                 return PTR_ERR(data);
2017
2018         rc = smk_parse_label_list(data, &list_tmp);
2019         kfree(data);
2020
2021         /*
2022          * Clear the smack_onlycap on invalid label errors. This means
2023          * that we can pass a null string to unset the onlycap value.
2024          *
2025          * Importing will also reject a label beginning with '-',
2026          * so "-usecapabilities" will also work.
2027          *
2028          * But do so only on invalid label, not on system errors.
2029          * The invalid label must be first to count as clearing attempt.
2030          */
2031         if (!rc || (rc == -EINVAL && list_empty(&list_tmp))) {
2032                 mutex_lock(&smack_onlycap_lock);
2033                 smk_list_swap_rcu(&smack_onlycap_list, &list_tmp);
2034                 mutex_unlock(&smack_onlycap_lock);
2035                 rc = count;
2036         }
2037
2038         smk_destroy_label_list(&list_tmp);
2039
2040         return rc;
2041 }
2042
2043 static const struct file_operations smk_onlycap_ops = {
2044         .open           = smk_open_onlycap,
2045         .read           = seq_read,
2046         .write          = smk_write_onlycap,
2047         .llseek         = seq_lseek,
2048         .release        = seq_release,
2049 };
2050
2051 #ifdef CONFIG_SECURITY_SMACK_BRINGUP
2052 /**
2053  * smk_read_unconfined - read() for smackfs/unconfined
2054  * @filp: file pointer, not actually used
2055  * @buf: where to put the result
2056  * @cn: maximum to send along
2057  * @ppos: where to start
2058  *
2059  * Returns number of bytes read or error code, as appropriate
2060  */
2061 static ssize_t smk_read_unconfined(struct file *filp, char __user *buf,
2062                                         size_t cn, loff_t *ppos)
2063 {
2064         char *smack = "";
2065         ssize_t rc = -EINVAL;
2066         int asize;
2067
2068         if (*ppos != 0)
2069                 return 0;
2070
2071         if (smack_unconfined != NULL)
2072                 smack = smack_unconfined->smk_known;
2073
2074         asize = strlen(smack) + 1;
2075
2076         if (cn >= asize)
2077                 rc = simple_read_from_buffer(buf, cn, ppos, smack, asize);
2078
2079         return rc;
2080 }
2081
2082 /**
2083  * smk_write_unconfined - write() for smackfs/unconfined
2084  * @file: file pointer, not actually used
2085  * @buf: where to get the data from
2086  * @count: bytes sent
2087  * @ppos: where to start
2088  *
2089  * Returns number of bytes written or error code, as appropriate
2090  */
2091 static ssize_t smk_write_unconfined(struct file *file, const char __user *buf,
2092                                         size_t count, loff_t *ppos)
2093 {
2094         char *data;
2095         struct smack_known *skp;
2096         int rc = count;
2097
2098         if (!smack_privileged(CAP_MAC_ADMIN))
2099                 return -EPERM;
2100
2101         if (count > PAGE_SIZE)
2102                 return -EINVAL;
2103
2104         data = memdup_user_nul(buf, count);
2105         if (IS_ERR(data))
2106                 return PTR_ERR(data);
2107
2108         /*
2109          * Clear the smack_unconfined on invalid label errors. This means
2110          * that we can pass a null string to unset the unconfined value.
2111          *
2112          * Importing will also reject a label beginning with '-',
2113          * so "-confine" will also work.
2114          *
2115          * But do so only on invalid label, not on system errors.
2116          */
2117         skp = smk_import_entry(data, count);
2118         if (PTR_ERR(skp) == -EINVAL)
2119                 skp = NULL;
2120         else if (IS_ERR(skp)) {
2121                 rc = PTR_ERR(skp);
2122                 goto freeout;
2123         }
2124
2125         smack_unconfined = skp;
2126
2127 freeout:
2128         kfree(data);
2129         return rc;
2130 }
2131
2132 static const struct file_operations smk_unconfined_ops = {
2133         .read           = smk_read_unconfined,
2134         .write          = smk_write_unconfined,
2135         .llseek         = default_llseek,
2136 };
2137 #endif /* CONFIG_SECURITY_SMACK_BRINGUP */
2138
2139 /**
2140  * smk_read_logging - read() for /smack/logging
2141  * @filp: file pointer, not actually used
2142  * @buf: where to put the result
2143  * @cn: maximum to send along
2144  * @ppos: where to start
2145  *
2146  * Returns number of bytes read or error code, as appropriate
2147  */
2148 static ssize_t smk_read_logging(struct file *filp, char __user *buf,
2149                                 size_t count, loff_t *ppos)
2150 {
2151         char temp[32];
2152         ssize_t rc;
2153
2154         if (*ppos != 0)
2155                 return 0;
2156
2157         sprintf(temp, "%d\n", log_policy);
2158         rc = simple_read_from_buffer(buf, count, ppos, temp, strlen(temp));
2159         return rc;
2160 }
2161
2162 /**
2163  * smk_write_logging - write() for /smack/logging
2164  * @file: file pointer, not actually used
2165  * @buf: where to get the data from
2166  * @count: bytes sent
2167  * @ppos: where to start
2168  *
2169  * Returns number of bytes written or error code, as appropriate
2170  */
2171 static ssize_t smk_write_logging(struct file *file, const char __user *buf,
2172                                 size_t count, loff_t *ppos)
2173 {
2174         char temp[32];
2175         int i;
2176
2177         if (!smack_privileged(CAP_MAC_ADMIN))
2178                 return -EPERM;
2179
2180         if (count >= sizeof(temp) || count == 0)
2181                 return -EINVAL;
2182
2183         if (copy_from_user(temp, buf, count) != 0)
2184                 return -EFAULT;
2185
2186         temp[count] = '\0';
2187
2188         if (sscanf(temp, "%d", &i) != 1)
2189                 return -EINVAL;
2190         if (i < 0 || i > 3)
2191                 return -EINVAL;
2192         log_policy = i;
2193         return count;
2194 }
2195
2196
2197
2198 static const struct file_operations smk_logging_ops = {
2199         .read           = smk_read_logging,
2200         .write          = smk_write_logging,
2201         .llseek         = default_llseek,
2202 };
2203
2204 /*
2205  * Seq_file read operations for /smack/load-self
2206  */
2207
2208 static void *load_self_seq_start(struct seq_file *s, loff_t *pos)
2209 {
2210         struct task_smack *tsp = smack_cred(current_cred());
2211
2212         return smk_seq_start(s, pos, &tsp->smk_rules);
2213 }
2214
2215 static void *load_self_seq_next(struct seq_file *s, void *v, loff_t *pos)
2216 {
2217         struct task_smack *tsp = smack_cred(current_cred());
2218
2219         return smk_seq_next(s, v, pos, &tsp->smk_rules);
2220 }
2221
2222 static int load_self_seq_show(struct seq_file *s, void *v)
2223 {
2224         struct list_head *list = v;
2225         struct smack_rule *srp =
2226                 list_entry_rcu(list, struct smack_rule, list);
2227
2228         smk_rule_show(s, srp, SMK_LABELLEN);
2229
2230         return 0;
2231 }
2232
2233 static const struct seq_operations load_self_seq_ops = {
2234         .start = load_self_seq_start,
2235         .next  = load_self_seq_next,
2236         .show  = load_self_seq_show,
2237         .stop  = smk_seq_stop,
2238 };
2239
2240
2241 /**
2242  * smk_open_load_self - open() for /smack/load-self2
2243  * @inode: inode structure representing file
2244  * @file: "load" file pointer
2245  *
2246  * For reading, use load_seq_* seq_file reading operations.
2247  */
2248 static int smk_open_load_self(struct inode *inode, struct file *file)
2249 {
2250         return seq_open(file, &load_self_seq_ops);
2251 }
2252
2253 /**
2254  * smk_write_load_self - write() for /smack/load-self
2255  * @file: file pointer, not actually used
2256  * @buf: where to get the data from
2257  * @count: bytes sent
2258  * @ppos: where to start - must be 0
2259  *
2260  */
2261 static ssize_t smk_write_load_self(struct file *file, const char __user *buf,
2262                               size_t count, loff_t *ppos)
2263 {
2264         struct task_smack *tsp = smack_cred(current_cred());
2265
2266         return smk_write_rules_list(file, buf, count, ppos, &tsp->smk_rules,
2267                                     &tsp->smk_rules_lock, SMK_FIXED24_FMT);
2268 }
2269
2270 static const struct file_operations smk_load_self_ops = {
2271         .open           = smk_open_load_self,
2272         .read           = seq_read,
2273         .llseek         = seq_lseek,
2274         .write          = smk_write_load_self,
2275         .release        = seq_release,
2276 };
2277
2278 /**
2279  * smk_user_access - handle access check transaction
2280  * @file: file pointer
2281  * @buf: data from user space
2282  * @count: bytes sent
2283  * @ppos: where to start - must be 0
2284  */
2285 static ssize_t smk_user_access(struct file *file, const char __user *buf,
2286                                 size_t count, loff_t *ppos, int format)
2287 {
2288         struct smack_parsed_rule rule;
2289         char *data;
2290         int res;
2291
2292         data = simple_transaction_get(file, buf, count);
2293         if (IS_ERR(data))
2294                 return PTR_ERR(data);
2295
2296         if (format == SMK_FIXED24_FMT) {
2297                 if (count < SMK_LOADLEN)
2298                         return -EINVAL;
2299                 res = smk_parse_rule(data, &rule, 0);
2300         } else {
2301                 /*
2302                  * simple_transaction_get() returns null-terminated data
2303                  */
2304                 res = smk_parse_long_rule(data, &rule, 0, 3);
2305         }
2306
2307         if (res >= 0)
2308                 res = smk_access(rule.smk_subject, rule.smk_object,
2309                                  rule.smk_access1, NULL);
2310         else if (res != -ENOENT)
2311                 return res;
2312
2313         /*
2314          * smk_access() can return a value > 0 in the "bringup" case.
2315          */
2316         data[0] = res >= 0 ? '1' : '0';
2317         data[1] = '\0';
2318
2319         simple_transaction_set(file, 2);
2320
2321         if (format == SMK_FIXED24_FMT)
2322                 return SMK_LOADLEN;
2323         return count;
2324 }
2325
2326 /**
2327  * smk_write_access - handle access check transaction
2328  * @file: file pointer
2329  * @buf: data from user space
2330  * @count: bytes sent
2331  * @ppos: where to start - must be 0
2332  */
2333 static ssize_t smk_write_access(struct file *file, const char __user *buf,
2334                                 size_t count, loff_t *ppos)
2335 {
2336         return smk_user_access(file, buf, count, ppos, SMK_FIXED24_FMT);
2337 }
2338
2339 static const struct file_operations smk_access_ops = {
2340         .write          = smk_write_access,
2341         .read           = simple_transaction_read,
2342         .release        = simple_transaction_release,
2343         .llseek         = generic_file_llseek,
2344 };
2345
2346
2347 /*
2348  * Seq_file read operations for /smack/load2
2349  */
2350
2351 static int load2_seq_show(struct seq_file *s, void *v)
2352 {
2353         struct list_head *list = v;
2354         struct smack_rule *srp;
2355         struct smack_known *skp =
2356                 list_entry_rcu(list, struct smack_known, list);
2357
2358         list_for_each_entry_rcu(srp, &skp->smk_rules, list)
2359                 smk_rule_show(s, srp, SMK_LONGLABEL);
2360
2361         return 0;
2362 }
2363
2364 static const struct seq_operations load2_seq_ops = {
2365         .start = load2_seq_start,
2366         .next  = load2_seq_next,
2367         .show  = load2_seq_show,
2368         .stop  = smk_seq_stop,
2369 };
2370
2371 /**
2372  * smk_open_load2 - open() for /smack/load2
2373  * @inode: inode structure representing file
2374  * @file: "load2" file pointer
2375  *
2376  * For reading, use load2_seq_* seq_file reading operations.
2377  */
2378 static int smk_open_load2(struct inode *inode, struct file *file)
2379 {
2380         return seq_open(file, &load2_seq_ops);
2381 }
2382
2383 /**
2384  * smk_write_load2 - write() for /smack/load2
2385  * @file: file pointer, not actually used
2386  * @buf: where to get the data from
2387  * @count: bytes sent
2388  * @ppos: where to start - must be 0
2389  *
2390  */
2391 static ssize_t smk_write_load2(struct file *file, const char __user *buf,
2392                                 size_t count, loff_t *ppos)
2393 {
2394         /*
2395          * Must have privilege.
2396          */
2397         if (!smack_privileged(CAP_MAC_ADMIN))
2398                 return -EPERM;
2399
2400         return smk_write_rules_list(file, buf, count, ppos, NULL, NULL,
2401                                     SMK_LONG_FMT);
2402 }
2403
2404 static const struct file_operations smk_load2_ops = {
2405         .open           = smk_open_load2,
2406         .read           = seq_read,
2407         .llseek         = seq_lseek,
2408         .write          = smk_write_load2,
2409         .release        = seq_release,
2410 };
2411
2412 /*
2413  * Seq_file read operations for /smack/load-self2
2414  */
2415
2416 static void *load_self2_seq_start(struct seq_file *s, loff_t *pos)
2417 {
2418         struct task_smack *tsp = smack_cred(current_cred());
2419
2420         return smk_seq_start(s, pos, &tsp->smk_rules);
2421 }
2422
2423 static void *load_self2_seq_next(struct seq_file *s, void *v, loff_t *pos)
2424 {
2425         struct task_smack *tsp = smack_cred(current_cred());
2426
2427         return smk_seq_next(s, v, pos, &tsp->smk_rules);
2428 }
2429
2430 static int load_self2_seq_show(struct seq_file *s, void *v)
2431 {
2432         struct list_head *list = v;
2433         struct smack_rule *srp =
2434                 list_entry_rcu(list, struct smack_rule, list);
2435
2436         smk_rule_show(s, srp, SMK_LONGLABEL);
2437
2438         return 0;
2439 }
2440
2441 static const struct seq_operations load_self2_seq_ops = {
2442         .start = load_self2_seq_start,
2443         .next  = load_self2_seq_next,
2444         .show  = load_self2_seq_show,
2445         .stop  = smk_seq_stop,
2446 };
2447
2448 /**
2449  * smk_open_load_self2 - open() for /smack/load-self2
2450  * @inode: inode structure representing file
2451  * @file: "load" file pointer
2452  *
2453  * For reading, use load_seq_* seq_file reading operations.
2454  */
2455 static int smk_open_load_self2(struct inode *inode, struct file *file)
2456 {
2457         return seq_open(file, &load_self2_seq_ops);
2458 }
2459
2460 /**
2461  * smk_write_load_self2 - write() for /smack/load-self2
2462  * @file: file pointer, not actually used
2463  * @buf: where to get the data from
2464  * @count: bytes sent
2465  * @ppos: where to start - must be 0
2466  *
2467  */
2468 static ssize_t smk_write_load_self2(struct file *file, const char __user *buf,
2469                               size_t count, loff_t *ppos)
2470 {
2471         struct task_smack *tsp = smack_cred(current_cred());
2472
2473         return smk_write_rules_list(file, buf, count, ppos, &tsp->smk_rules,
2474                                     &tsp->smk_rules_lock, SMK_LONG_FMT);
2475 }
2476
2477 static const struct file_operations smk_load_self2_ops = {
2478         .open           = smk_open_load_self2,
2479         .read           = seq_read,
2480         .llseek         = seq_lseek,
2481         .write          = smk_write_load_self2,
2482         .release        = seq_release,
2483 };
2484
2485 /**
2486  * smk_write_access2 - handle access check transaction
2487  * @file: file pointer
2488  * @buf: data from user space
2489  * @count: bytes sent
2490  * @ppos: where to start - must be 0
2491  */
2492 static ssize_t smk_write_access2(struct file *file, const char __user *buf,
2493                                         size_t count, loff_t *ppos)
2494 {
2495         return smk_user_access(file, buf, count, ppos, SMK_LONG_FMT);
2496 }
2497
2498 static const struct file_operations smk_access2_ops = {
2499         .write          = smk_write_access2,
2500         .read           = simple_transaction_read,
2501         .release        = simple_transaction_release,
2502         .llseek         = generic_file_llseek,
2503 };
2504
2505 /**
2506  * smk_write_revoke_subj - write() for /smack/revoke-subject
2507  * @file: file pointer
2508  * @buf: data from user space
2509  * @count: bytes sent
2510  * @ppos: where to start - must be 0
2511  */
2512 static ssize_t smk_write_revoke_subj(struct file *file, const char __user *buf,
2513                                 size_t count, loff_t *ppos)
2514 {
2515         char *data;
2516         const char *cp;
2517         struct smack_known *skp;
2518         struct smack_rule *sp;
2519         struct list_head *rule_list;
2520         struct mutex *rule_lock;
2521         int rc = count;
2522
2523         if (*ppos != 0)
2524                 return -EINVAL;
2525
2526         if (!smack_privileged(CAP_MAC_ADMIN))
2527                 return -EPERM;
2528
2529         if (count == 0 || count > SMK_LONGLABEL)
2530                 return -EINVAL;
2531
2532         data = memdup_user(buf, count);
2533         if (IS_ERR(data))
2534                 return PTR_ERR(data);
2535
2536         cp = smk_parse_smack(data, count);
2537         if (IS_ERR(cp)) {
2538                 rc = PTR_ERR(cp);
2539                 goto out_data;
2540         }
2541
2542         skp = smk_find_entry(cp);
2543         if (skp == NULL)
2544                 goto out_cp;
2545
2546         rule_list = &skp->smk_rules;
2547         rule_lock = &skp->smk_rules_lock;
2548
2549         mutex_lock(rule_lock);
2550
2551         list_for_each_entry_rcu(sp, rule_list, list)
2552                 sp->smk_access = 0;
2553
2554         mutex_unlock(rule_lock);
2555
2556 out_cp:
2557         kfree(cp);
2558 out_data:
2559         kfree(data);
2560
2561         return rc;
2562 }
2563
2564 static const struct file_operations smk_revoke_subj_ops = {
2565         .write          = smk_write_revoke_subj,
2566         .read           = simple_transaction_read,
2567         .release        = simple_transaction_release,
2568         .llseek         = generic_file_llseek,
2569 };
2570
2571 /**
2572  * smk_init_sysfs - initialize /sys/fs/smackfs
2573  *
2574  */
2575 static int smk_init_sysfs(void)
2576 {
2577         return sysfs_create_mount_point(fs_kobj, "smackfs");
2578 }
2579
2580 /**
2581  * smk_write_change_rule - write() for /smack/change-rule
2582  * @file: file pointer
2583  * @buf: data from user space
2584  * @count: bytes sent
2585  * @ppos: where to start - must be 0
2586  */
2587 static ssize_t smk_write_change_rule(struct file *file, const char __user *buf,
2588                                 size_t count, loff_t *ppos)
2589 {
2590         /*
2591          * Must have privilege.
2592          */
2593         if (!smack_privileged(CAP_MAC_ADMIN))
2594                 return -EPERM;
2595
2596         return smk_write_rules_list(file, buf, count, ppos, NULL, NULL,
2597                                     SMK_CHANGE_FMT);
2598 }
2599
2600 static const struct file_operations smk_change_rule_ops = {
2601         .write          = smk_write_change_rule,
2602         .read           = simple_transaction_read,
2603         .release        = simple_transaction_release,
2604         .llseek         = generic_file_llseek,
2605 };
2606
2607 /**
2608  * smk_read_syslog - read() for smackfs/syslog
2609  * @filp: file pointer, not actually used
2610  * @buf: where to put the result
2611  * @cn: maximum to send along
2612  * @ppos: where to start
2613  *
2614  * Returns number of bytes read or error code, as appropriate
2615  */
2616 static ssize_t smk_read_syslog(struct file *filp, char __user *buf,
2617                                 size_t cn, loff_t *ppos)
2618 {
2619         struct smack_known *skp;
2620         ssize_t rc = -EINVAL;
2621         int asize;
2622
2623         if (*ppos != 0)
2624                 return 0;
2625
2626         if (smack_syslog_label == NULL)
2627                 skp = &smack_known_star;
2628         else
2629                 skp = smack_syslog_label;
2630
2631         asize = strlen(skp->smk_known) + 1;
2632
2633         if (cn >= asize)
2634                 rc = simple_read_from_buffer(buf, cn, ppos, skp->smk_known,
2635                                                 asize);
2636
2637         return rc;
2638 }
2639
2640 /**
2641  * smk_write_syslog - write() for smackfs/syslog
2642  * @file: file pointer, not actually used
2643  * @buf: where to get the data from
2644  * @count: bytes sent
2645  * @ppos: where to start
2646  *
2647  * Returns number of bytes written or error code, as appropriate
2648  */
2649 static ssize_t smk_write_syslog(struct file *file, const char __user *buf,
2650                                 size_t count, loff_t *ppos)
2651 {
2652         char *data;
2653         struct smack_known *skp;
2654         int rc = count;
2655
2656         if (!smack_privileged(CAP_MAC_ADMIN))
2657                 return -EPERM;
2658
2659         /* Enough data must be present */
2660         if (count == 0 || count > PAGE_SIZE)
2661                 return -EINVAL;
2662
2663         data = memdup_user_nul(buf, count);
2664         if (IS_ERR(data))
2665                 return PTR_ERR(data);
2666
2667         skp = smk_import_entry(data, count);
2668         if (IS_ERR(skp))
2669                 rc = PTR_ERR(skp);
2670         else
2671                 smack_syslog_label = skp;
2672
2673         kfree(data);
2674         return rc;
2675 }
2676
2677 static const struct file_operations smk_syslog_ops = {
2678         .read           = smk_read_syslog,
2679         .write          = smk_write_syslog,
2680         .llseek         = default_llseek,
2681 };
2682
2683 /*
2684  * Seq_file read operations for /smack/relabel-self
2685  */
2686
2687 static void *relabel_self_seq_start(struct seq_file *s, loff_t *pos)
2688 {
2689         struct task_smack *tsp = smack_cred(current_cred());
2690
2691         return smk_seq_start(s, pos, &tsp->smk_relabel);
2692 }
2693
2694 static void *relabel_self_seq_next(struct seq_file *s, void *v, loff_t *pos)
2695 {
2696         struct task_smack *tsp = smack_cred(current_cred());
2697
2698         return smk_seq_next(s, v, pos, &tsp->smk_relabel);
2699 }
2700
2701 static int relabel_self_seq_show(struct seq_file *s, void *v)
2702 {
2703         struct list_head *list = v;
2704         struct smack_known_list_elem *sklep =
2705                 list_entry(list, struct smack_known_list_elem, list);
2706
2707         seq_puts(s, sklep->smk_label->smk_known);
2708         seq_putc(s, ' ');
2709
2710         return 0;
2711 }
2712
2713 static const struct seq_operations relabel_self_seq_ops = {
2714         .start = relabel_self_seq_start,
2715         .next  = relabel_self_seq_next,
2716         .show  = relabel_self_seq_show,
2717         .stop  = smk_seq_stop,
2718 };
2719
2720 /**
2721  * smk_open_relabel_self - open() for /smack/relabel-self
2722  * @inode: inode structure representing file
2723  * @file: "relabel-self" file pointer
2724  *
2725  * Connect our relabel_self_seq_* operations with /smack/relabel-self
2726  * file_operations
2727  */
2728 static int smk_open_relabel_self(struct inode *inode, struct file *file)
2729 {
2730         return seq_open(file, &relabel_self_seq_ops);
2731 }
2732
2733 /**
2734  * smk_write_relabel_self - write() for /smack/relabel-self
2735  * @file: file pointer, not actually used
2736  * @buf: where to get the data from
2737  * @count: bytes sent
2738  * @ppos: where to start - must be 0
2739  *
2740  */
2741 static ssize_t smk_write_relabel_self(struct file *file, const char __user *buf,
2742                                 size_t count, loff_t *ppos)
2743 {
2744         char *data;
2745         int rc;
2746         LIST_HEAD(list_tmp);
2747
2748         /*
2749          * Must have privilege.
2750          */
2751         if (!smack_privileged(CAP_MAC_ADMIN))
2752                 return -EPERM;
2753
2754         /*
2755          * No partial write.
2756          * Enough data must be present.
2757          */
2758         if (*ppos != 0)
2759                 return -EINVAL;
2760         if (count == 0 || count > PAGE_SIZE)
2761                 return -EINVAL;
2762
2763         data = memdup_user_nul(buf, count);
2764         if (IS_ERR(data))
2765                 return PTR_ERR(data);
2766
2767         rc = smk_parse_label_list(data, &list_tmp);
2768         kfree(data);
2769
2770         if (!rc || (rc == -EINVAL && list_empty(&list_tmp))) {
2771                 struct cred *new;
2772                 struct task_smack *tsp;
2773
2774                 new = prepare_creds();
2775                 if (!new) {
2776                         rc = -ENOMEM;
2777                         goto out;
2778                 }
2779                 tsp = smack_cred(new);
2780                 smk_destroy_label_list(&tsp->smk_relabel);
2781                 list_splice(&list_tmp, &tsp->smk_relabel);
2782                 commit_creds(new);
2783                 return count;
2784         }
2785 out:
2786         smk_destroy_label_list(&list_tmp);
2787         return rc;
2788 }
2789
2790 static const struct file_operations smk_relabel_self_ops = {
2791         .open           = smk_open_relabel_self,
2792         .read           = seq_read,
2793         .llseek         = seq_lseek,
2794         .write          = smk_write_relabel_self,
2795         .release        = seq_release,
2796 };
2797
2798 /**
2799  * smk_read_ptrace - read() for /smack/ptrace
2800  * @filp: file pointer, not actually used
2801  * @buf: where to put the result
2802  * @count: maximum to send along
2803  * @ppos: where to start
2804  *
2805  * Returns number of bytes read or error code, as appropriate
2806  */
2807 static ssize_t smk_read_ptrace(struct file *filp, char __user *buf,
2808                                size_t count, loff_t *ppos)
2809 {
2810         char temp[32];
2811         ssize_t rc;
2812
2813         if (*ppos != 0)
2814                 return 0;
2815
2816         sprintf(temp, "%d\n", smack_ptrace_rule);
2817         rc = simple_read_from_buffer(buf, count, ppos, temp, strlen(temp));
2818         return rc;
2819 }
2820
2821 /**
2822  * smk_write_ptrace - write() for /smack/ptrace
2823  * @file: file pointer
2824  * @buf: data from user space
2825  * @count: bytes sent
2826  * @ppos: where to start - must be 0
2827  */
2828 static ssize_t smk_write_ptrace(struct file *file, const char __user *buf,
2829                                 size_t count, loff_t *ppos)
2830 {
2831         char temp[32];
2832         int i;
2833
2834         if (!smack_privileged(CAP_MAC_ADMIN))
2835                 return -EPERM;
2836
2837         if (*ppos != 0 || count >= sizeof(temp) || count == 0)
2838                 return -EINVAL;
2839
2840         if (copy_from_user(temp, buf, count) != 0)
2841                 return -EFAULT;
2842
2843         temp[count] = '\0';
2844
2845         if (sscanf(temp, "%d", &i) != 1)
2846                 return -EINVAL;
2847         if (i < SMACK_PTRACE_DEFAULT || i > SMACK_PTRACE_MAX)
2848                 return -EINVAL;
2849         smack_ptrace_rule = i;
2850
2851         return count;
2852 }
2853
2854 static const struct file_operations smk_ptrace_ops = {
2855         .write          = smk_write_ptrace,
2856         .read           = smk_read_ptrace,
2857         .llseek         = default_llseek,
2858 };
2859
2860 /**
2861  * smk_fill_super - fill the smackfs superblock
2862  * @sb: the empty superblock
2863  * @fc: unused
2864  *
2865  * Fill in the well known entries for the smack filesystem
2866  *
2867  * Returns 0 on success, an error code on failure
2868  */
2869 static int smk_fill_super(struct super_block *sb, struct fs_context *fc)
2870 {
2871         int rc;
2872
2873         static const struct tree_descr smack_files[] = {
2874                 [SMK_LOAD] = {
2875                         "load", &smk_load_ops, S_IRUGO|S_IWUSR},
2876                 [SMK_CIPSO] = {
2877                         "cipso", &smk_cipso_ops, S_IRUGO|S_IWUSR},
2878                 [SMK_DOI] = {
2879                         "doi", &smk_doi_ops, S_IRUGO|S_IWUSR},
2880                 [SMK_DIRECT] = {
2881                         "direct", &smk_direct_ops, S_IRUGO|S_IWUSR},
2882                 [SMK_AMBIENT] = {
2883                         "ambient", &smk_ambient_ops, S_IRUGO|S_IWUSR},
2884                 [SMK_NET4ADDR] = {
2885                         "netlabel", &smk_net4addr_ops, S_IRUGO|S_IWUSR},
2886                 [SMK_ONLYCAP] = {
2887                         "onlycap", &smk_onlycap_ops, S_IRUGO|S_IWUSR},
2888                 [SMK_LOGGING] = {
2889                         "logging", &smk_logging_ops, S_IRUGO|S_IWUSR},
2890                 [SMK_LOAD_SELF] = {
2891                         "load-self", &smk_load_self_ops, S_IRUGO|S_IWUGO},
2892                 [SMK_ACCESSES] = {
2893                         "access", &smk_access_ops, S_IRUGO|S_IWUGO},
2894                 [SMK_MAPPED] = {
2895                         "mapped", &smk_mapped_ops, S_IRUGO|S_IWUSR},
2896                 [SMK_LOAD2] = {
2897                         "load2", &smk_load2_ops, S_IRUGO|S_IWUSR},
2898                 [SMK_LOAD_SELF2] = {
2899                         "load-self2", &smk_load_self2_ops, S_IRUGO|S_IWUGO},
2900                 [SMK_ACCESS2] = {
2901                         "access2", &smk_access2_ops, S_IRUGO|S_IWUGO},
2902                 [SMK_CIPSO2] = {
2903                         "cipso2", &smk_cipso2_ops, S_IRUGO|S_IWUSR},
2904                 [SMK_REVOKE_SUBJ] = {
2905                         "revoke-subject", &smk_revoke_subj_ops,
2906                         S_IRUGO|S_IWUSR},
2907                 [SMK_CHANGE_RULE] = {
2908                         "change-rule", &smk_change_rule_ops, S_IRUGO|S_IWUSR},
2909                 [SMK_SYSLOG] = {
2910                         "syslog", &smk_syslog_ops, S_IRUGO|S_IWUSR},
2911                 [SMK_PTRACE] = {
2912                         "ptrace", &smk_ptrace_ops, S_IRUGO|S_IWUSR},
2913 #ifdef CONFIG_SECURITY_SMACK_BRINGUP
2914                 [SMK_UNCONFINED] = {
2915                         "unconfined", &smk_unconfined_ops, S_IRUGO|S_IWUSR},
2916 #endif
2917 #if IS_ENABLED(CONFIG_IPV6)
2918                 [SMK_NET6ADDR] = {
2919                         "ipv6host", &smk_net6addr_ops, S_IRUGO|S_IWUSR},
2920 #endif /* CONFIG_IPV6 */
2921                 [SMK_RELABEL_SELF] = {
2922                         "relabel-self", &smk_relabel_self_ops,
2923                                 S_IRUGO|S_IWUGO},
2924                 /* last one */
2925                         {""}
2926         };
2927
2928         rc = simple_fill_super(sb, SMACK_MAGIC, smack_files);
2929         if (rc != 0) {
2930                 printk(KERN_ERR "%s failed %d while creating inodes\n",
2931                         __func__, rc);
2932                 return rc;
2933         }
2934
2935         return 0;
2936 }
2937
2938 /**
2939  * smk_get_tree - get the smackfs superblock
2940  * @fc: The mount context, including any options
2941  *
2942  * Just passes everything along.
2943  *
2944  * Returns what the lower level code does.
2945  */
2946 static int smk_get_tree(struct fs_context *fc)
2947 {
2948         return get_tree_single(fc, smk_fill_super);
2949 }
2950
2951 static const struct fs_context_operations smk_context_ops = {
2952         .get_tree       = smk_get_tree,
2953 };
2954
2955 /**
2956  * smk_init_fs_context - Initialise a filesystem context for smackfs
2957  * @fc: The blank mount context
2958  */
2959 static int smk_init_fs_context(struct fs_context *fc)
2960 {
2961         fc->ops = &smk_context_ops;
2962         return 0;
2963 }
2964
2965 static struct file_system_type smk_fs_type = {
2966         .name           = "smackfs",
2967         .init_fs_context = smk_init_fs_context,
2968         .kill_sb        = kill_litter_super,
2969 };
2970
2971 static struct vfsmount *smackfs_mount;
2972
2973 static int __init smk_preset_netlabel(struct smack_known *skp)
2974 {
2975         skp->smk_netlabel.domain = skp->smk_known;
2976         skp->smk_netlabel.flags =
2977                 NETLBL_SECATTR_DOMAIN | NETLBL_SECATTR_MLS_LVL;
2978         return smk_netlbl_mls(smack_cipso_direct, skp->smk_known,
2979                                 &skp->smk_netlabel, strlen(skp->smk_known));
2980 }
2981
2982 /**
2983  * init_smk_fs - get the smackfs superblock
2984  *
2985  * register the smackfs
2986  *
2987  * Do not register smackfs if Smack wasn't enabled
2988  * on boot. We can not put this method normally under the
2989  * smack_init() code path since the security subsystem get
2990  * initialized before the vfs caches.
2991  *
2992  * Returns true if we were not chosen on boot or if
2993  * we were chosen and filesystem registration succeeded.
2994  */
2995 static int __init init_smk_fs(void)
2996 {
2997         int err;
2998         int rc;
2999
3000         if (smack_enabled == 0)
3001                 return 0;
3002
3003         err = smk_init_sysfs();
3004         if (err)
3005                 printk(KERN_ERR "smackfs: sysfs mountpoint problem.\n");
3006
3007         err = register_filesystem(&smk_fs_type);
3008         if (!err) {
3009                 smackfs_mount = kern_mount(&smk_fs_type);
3010                 if (IS_ERR(smackfs_mount)) {
3011                         printk(KERN_ERR "smackfs:  could not mount!\n");
3012                         err = PTR_ERR(smackfs_mount);
3013                         smackfs_mount = NULL;
3014                 }
3015         }
3016
3017         smk_cipso_doi();
3018         smk_unlbl_ambient(NULL);
3019
3020         rc = smk_preset_netlabel(&smack_known_floor);
3021         if (err == 0 && rc < 0)
3022                 err = rc;
3023         rc = smk_preset_netlabel(&smack_known_hat);
3024         if (err == 0 && rc < 0)
3025                 err = rc;
3026         rc = smk_preset_netlabel(&smack_known_huh);
3027         if (err == 0 && rc < 0)
3028                 err = rc;
3029         rc = smk_preset_netlabel(&smack_known_star);
3030         if (err == 0 && rc < 0)
3031                 err = rc;
3032         rc = smk_preset_netlabel(&smack_known_web);
3033         if (err == 0 && rc < 0)
3034                 err = rc;
3035
3036         return err;
3037 }
3038
3039 __initcall(init_smk_fs);