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