Daniel Campello | 35c9e24 | 2015-07-20 16:23:50 -0700 | [diff] [blame] | 1 | /* |
| 2 | * fs/sdcardfs/packagelist.c |
| 3 | * |
| 4 | * Copyright (c) 2013 Samsung Electronics Co. Ltd |
| 5 | * Authors: Daeho Jeong, Woojoong Lee, Seunghwan Hyun, |
| 6 | * Sunghwan Yun, Sungjong Seo |
| 7 | * |
| 8 | * This program has been developed as a stackable file system based on |
| 9 | * the WrapFS which written by |
| 10 | * |
| 11 | * Copyright (c) 1998-2011 Erez Zadok |
| 12 | * Copyright (c) 2009 Shrikar Archak |
| 13 | * Copyright (c) 2003-2011 Stony Brook University |
| 14 | * Copyright (c) 2003-2011 The Research Foundation of SUNY |
| 15 | * |
| 16 | * This file is dual licensed. It may be redistributed and/or modified |
| 17 | * under the terms of the Apache 2.0 License OR version 2 of the GNU |
| 18 | * General Public License. |
| 19 | */ |
| 20 | |
| 21 | #include "sdcardfs.h" |
Daniel Campello | d1d080c | 2015-07-20 16:27:37 -0700 | [diff] [blame] | 22 | #include <linux/hashtable.h> |
Daniel Rosenberg | a8c2078 | 2017-03-10 12:39:42 -0800 | [diff] [blame] | 23 | #include <linux/ctype.h> |
Daniel Campello | 35c9e24 | 2015-07-20 16:23:50 -0700 | [diff] [blame] | 24 | #include <linux/delay.h> |
Daniel Rosenberg | ad90525 | 2017-01-25 13:48:45 -0800 | [diff] [blame] | 25 | #include <linux/radix-tree.h> |
Daniel Rosenberg | 52b7768 | 2017-01-27 19:35:08 -0800 | [diff] [blame] | 26 | #include <linux/dcache.h> |
Daniel Rosenberg | 497ac90 | 2016-02-03 21:08:21 -0800 | [diff] [blame] | 27 | |
| 28 | #include <linux/init.h> |
| 29 | #include <linux/module.h> |
| 30 | #include <linux/slab.h> |
| 31 | |
| 32 | #include <linux/configfs.h> |
| 33 | |
Daniel Campello | 35c9e24 | 2015-07-20 16:23:50 -0700 | [diff] [blame] | 34 | struct hashtable_entry { |
Daniel Campello | d1d080c | 2015-07-20 16:27:37 -0700 | [diff] [blame] | 35 | struct hlist_node hlist; |
Daniel Rosenberg | d8caaf9 | 2017-01-22 15:32:49 -0800 | [diff] [blame] | 36 | struct hlist_node dlist; /* for deletion cleanup */ |
Daniel Rosenberg | 52b7768 | 2017-01-27 19:35:08 -0800 | [diff] [blame] | 37 | struct qstr key; |
Daniel Rosenberg | fbd34b6 | 2016-05-10 13:42:43 -0700 | [diff] [blame] | 38 | atomic_t value; |
Daniel Campello | 35c9e24 | 2015-07-20 16:23:50 -0700 | [diff] [blame] | 39 | }; |
| 40 | |
Daniel Rosenberg | fbd34b6 | 2016-05-10 13:42:43 -0700 | [diff] [blame] | 41 | static DEFINE_HASHTABLE(package_to_appid, 8); |
Daniel Rosenberg | d8caaf9 | 2017-01-22 15:32:49 -0800 | [diff] [blame] | 42 | static DEFINE_HASHTABLE(package_to_userid, 8); |
Daniel Rosenberg | ad90525 | 2017-01-25 13:48:45 -0800 | [diff] [blame] | 43 | static DEFINE_HASHTABLE(ext_to_groupid, 8); |
| 44 | |
Daniel Rosenberg | 497ac90 | 2016-02-03 21:08:21 -0800 | [diff] [blame] | 45 | |
| 46 | static struct kmem_cache *hashtable_entry_cachep; |
Daniel Campello | 35c9e24 | 2015-07-20 16:23:50 -0700 | [diff] [blame] | 47 | |
Daniel Rosenberg | a8c2078 | 2017-03-10 12:39:42 -0800 | [diff] [blame] | 48 | static unsigned int full_name_case_hash(const void *salt, const unsigned char *name, unsigned int len) |
| 49 | { |
| 50 | unsigned long hash = init_name_hash(salt); |
Daniel Rosenberg | 9608a4a | 2017-03-21 16:28:27 -0700 | [diff] [blame] | 51 | |
Daniel Rosenberg | a8c2078 | 2017-03-10 12:39:42 -0800 | [diff] [blame] | 52 | while (len--) |
| 53 | hash = partial_name_hash(tolower(*name++), hash); |
| 54 | return end_name_hash(hash); |
| 55 | } |
| 56 | |
Daniel Rosenberg | 52b7768 | 2017-01-27 19:35:08 -0800 | [diff] [blame] | 57 | static inline void qstr_init(struct qstr *q, const char *name) |
| 58 | { |
| 59 | q->name = name; |
| 60 | q->len = strlen(q->name); |
Daniel Rosenberg | a8c2078 | 2017-03-10 12:39:42 -0800 | [diff] [blame] | 61 | q->hash = full_name_case_hash(0, q->name, q->len); |
Daniel Campello | 35c9e24 | 2015-07-20 16:23:50 -0700 | [diff] [blame] | 62 | } |
| 63 | |
Daniel Rosenberg | 52b7768 | 2017-01-27 19:35:08 -0800 | [diff] [blame] | 64 | static inline int qstr_copy(const struct qstr *src, struct qstr *dest) |
| 65 | { |
| 66 | dest->name = kstrdup(src->name, GFP_KERNEL); |
| 67 | dest->hash_len = src->hash_len; |
| 68 | return !!dest->name; |
| 69 | } |
| 70 | |
| 71 | |
| 72 | static appid_t __get_appid(const struct qstr *key) |
Daniel Campello | 35c9e24 | 2015-07-20 16:23:50 -0700 | [diff] [blame] | 73 | { |
Daniel Campello | 35c9e24 | 2015-07-20 16:23:50 -0700 | [diff] [blame] | 74 | struct hashtable_entry *hash_cur; |
Daniel Rosenberg | 52b7768 | 2017-01-27 19:35:08 -0800 | [diff] [blame] | 75 | unsigned int hash = key->hash; |
Daniel Campello | 35c9e24 | 2015-07-20 16:23:50 -0700 | [diff] [blame] | 76 | appid_t ret_id; |
| 77 | |
Daniel Rosenberg | fbd34b6 | 2016-05-10 13:42:43 -0700 | [diff] [blame] | 78 | rcu_read_lock(); |
| 79 | hash_for_each_possible_rcu(package_to_appid, hash_cur, hlist, hash) { |
Daniel Rosenberg | 5004c5f | 2017-01-31 20:07:51 -0800 | [diff] [blame] | 80 | if (qstr_case_eq(key, &hash_cur->key)) { |
Daniel Rosenberg | 52b7768 | 2017-01-27 19:35:08 -0800 | [diff] [blame] | 81 | ret_id = atomic_read(&hash_cur->value); |
| 82 | rcu_read_unlock(); |
| 83 | return ret_id; |
| 84 | } |
| 85 | } |
| 86 | rcu_read_unlock(); |
| 87 | return 0; |
| 88 | } |
| 89 | |
| 90 | appid_t get_appid(const char *key) |
| 91 | { |
| 92 | struct qstr q; |
Daniel Rosenberg | 5e024f6 | 2017-03-16 17:42:58 -0700 | [diff] [blame] | 93 | |
Daniel Rosenberg | 52b7768 | 2017-01-27 19:35:08 -0800 | [diff] [blame] | 94 | qstr_init(&q, key); |
| 95 | return __get_appid(&q); |
| 96 | } |
| 97 | |
| 98 | static appid_t __get_ext_gid(const struct qstr *key) |
| 99 | { |
| 100 | struct hashtable_entry *hash_cur; |
| 101 | unsigned int hash = key->hash; |
| 102 | appid_t ret_id; |
| 103 | |
| 104 | rcu_read_lock(); |
| 105 | hash_for_each_possible_rcu(ext_to_groupid, hash_cur, hlist, hash) { |
Daniel Rosenberg | 5004c5f | 2017-01-31 20:07:51 -0800 | [diff] [blame] | 106 | if (qstr_case_eq(key, &hash_cur->key)) { |
Daniel Rosenberg | ad90525 | 2017-01-25 13:48:45 -0800 | [diff] [blame] | 107 | ret_id = atomic_read(&hash_cur->value); |
| 108 | rcu_read_unlock(); |
| 109 | return ret_id; |
| 110 | } |
| 111 | } |
| 112 | rcu_read_unlock(); |
| 113 | return 0; |
| 114 | } |
| 115 | |
| 116 | appid_t get_ext_gid(const char *key) |
| 117 | { |
Daniel Rosenberg | 52b7768 | 2017-01-27 19:35:08 -0800 | [diff] [blame] | 118 | struct qstr q; |
Daniel Rosenberg | 5e024f6 | 2017-03-16 17:42:58 -0700 | [diff] [blame] | 119 | |
Daniel Rosenberg | 52b7768 | 2017-01-27 19:35:08 -0800 | [diff] [blame] | 120 | qstr_init(&q, key); |
| 121 | return __get_ext_gid(&q); |
| 122 | } |
| 123 | |
| 124 | static appid_t __is_excluded(const struct qstr *app_name, userid_t user) |
| 125 | { |
Daniel Rosenberg | ad90525 | 2017-01-25 13:48:45 -0800 | [diff] [blame] | 126 | struct hashtable_entry *hash_cur; |
Daniel Rosenberg | 52b7768 | 2017-01-27 19:35:08 -0800 | [diff] [blame] | 127 | unsigned int hash = app_name->hash; |
Daniel Rosenberg | ad90525 | 2017-01-25 13:48:45 -0800 | [diff] [blame] | 128 | |
| 129 | rcu_read_lock(); |
Daniel Rosenberg | 52b7768 | 2017-01-27 19:35:08 -0800 | [diff] [blame] | 130 | hash_for_each_possible_rcu(package_to_userid, hash_cur, hlist, hash) { |
| 131 | if (atomic_read(&hash_cur->value) == user && |
Daniel Rosenberg | 5004c5f | 2017-01-31 20:07:51 -0800 | [diff] [blame] | 132 | qstr_case_eq(app_name, &hash_cur->key)) { |
Daniel Rosenberg | fbd34b6 | 2016-05-10 13:42:43 -0700 | [diff] [blame] | 133 | rcu_read_unlock(); |
Daniel Rosenberg | 52b7768 | 2017-01-27 19:35:08 -0800 | [diff] [blame] | 134 | return 1; |
Daniel Campello | 35c9e24 | 2015-07-20 16:23:50 -0700 | [diff] [blame] | 135 | } |
| 136 | } |
Daniel Rosenberg | fbd34b6 | 2016-05-10 13:42:43 -0700 | [diff] [blame] | 137 | rcu_read_unlock(); |
Daniel Campello | 35c9e24 | 2015-07-20 16:23:50 -0700 | [diff] [blame] | 138 | return 0; |
| 139 | } |
| 140 | |
Daniel Rosenberg | 5004c5f | 2017-01-31 20:07:51 -0800 | [diff] [blame] | 141 | appid_t is_excluded(const char *key, userid_t user) |
Daniel Rosenberg | d8caaf9 | 2017-01-22 15:32:49 -0800 | [diff] [blame] | 142 | { |
Daniel Rosenberg | 52b7768 | 2017-01-27 19:35:08 -0800 | [diff] [blame] | 143 | struct qstr q; |
Daniel Rosenberg | 5004c5f | 2017-01-31 20:07:51 -0800 | [diff] [blame] | 144 | qstr_init(&q, key); |
Daniel Rosenberg | 52b7768 | 2017-01-27 19:35:08 -0800 | [diff] [blame] | 145 | return __is_excluded(&q, user); |
Daniel Rosenberg | d8caaf9 | 2017-01-22 15:32:49 -0800 | [diff] [blame] | 146 | } |
| 147 | |
Daniel Campello | 35c9e24 | 2015-07-20 16:23:50 -0700 | [diff] [blame] | 148 | /* Kernel has already enforced everything we returned through |
| 149 | * derive_permissions_locked(), so this is used to lock down access |
Daniel Rosenberg | 5e024f6 | 2017-03-16 17:42:58 -0700 | [diff] [blame] | 150 | * even further, such as enforcing that apps hold sdcard_rw. |
| 151 | */ |
Daniel Rosenberg | 5004c5f | 2017-01-31 20:07:51 -0800 | [diff] [blame] | 152 | int check_caller_access_to_name(struct inode *parent_node, const struct qstr *name) |
Daniel Rosenberg | ad90525 | 2017-01-25 13:48:45 -0800 | [diff] [blame] | 153 | { |
Daniel Rosenberg | 5004c5f | 2017-01-31 20:07:51 -0800 | [diff] [blame] | 154 | struct qstr q_autorun = QSTR_LITERAL("autorun.inf"); |
| 155 | struct qstr q__android_secure = QSTR_LITERAL(".android_secure"); |
| 156 | struct qstr q_android_secure = QSTR_LITERAL("android_secure"); |
| 157 | |
Daniel Campello | 35c9e24 | 2015-07-20 16:23:50 -0700 | [diff] [blame] | 158 | /* Always block security-sensitive files at root */ |
Daniel Rosenberg | a56a105 | 2017-05-15 14:03:15 -0700 | [diff] [blame] | 159 | if (parent_node && SDCARDFS_I(parent_node)->data->perm == PERM_ROOT) { |
Daniel Rosenberg | 5004c5f | 2017-01-31 20:07:51 -0800 | [diff] [blame] | 160 | if (qstr_case_eq(name, &q_autorun) |
| 161 | || qstr_case_eq(name, &q__android_secure) |
| 162 | || qstr_case_eq(name, &q_android_secure)) { |
Daniel Campello | 35c9e24 | 2015-07-20 16:23:50 -0700 | [diff] [blame] | 163 | return 0; |
| 164 | } |
| 165 | } |
| 166 | |
Daniel Campello | 35c9e24 | 2015-07-20 16:23:50 -0700 | [diff] [blame] | 167 | /* Root always has access; access for any other UIDs should always |
Daniel Rosenberg | 5e024f6 | 2017-03-16 17:42:58 -0700 | [diff] [blame] | 168 | * be controlled through packages.list. |
| 169 | */ |
| 170 | if (from_kuid(&init_user_ns, current_fsuid()) == 0) |
Daniel Campello | 35c9e24 | 2015-07-20 16:23:50 -0700 | [diff] [blame] | 171 | return 1; |
Daniel Campello | 35c9e24 | 2015-07-20 16:23:50 -0700 | [diff] [blame] | 172 | |
Daniel Campello | 35c9e24 | 2015-07-20 16:23:50 -0700 | [diff] [blame] | 173 | /* No extra permissions to enforce */ |
| 174 | return 1; |
| 175 | } |
| 176 | |
Daniel Rosenberg | 52b7768 | 2017-01-27 19:35:08 -0800 | [diff] [blame] | 177 | static struct hashtable_entry *alloc_hashtable_entry(const struct qstr *key, |
Daniel Rosenberg | fbd34b6 | 2016-05-10 13:42:43 -0700 | [diff] [blame] | 178 | appid_t value) |
| 179 | { |
| 180 | struct hashtable_entry *ret = kmem_cache_alloc(hashtable_entry_cachep, |
| 181 | GFP_KERNEL); |
| 182 | if (!ret) |
| 183 | return NULL; |
Daniel Rosenberg | 1df4842 | 2017-02-22 14:41:58 -0800 | [diff] [blame] | 184 | INIT_HLIST_NODE(&ret->dlist); |
| 185 | INIT_HLIST_NODE(&ret->hlist); |
Daniel Rosenberg | fbd34b6 | 2016-05-10 13:42:43 -0700 | [diff] [blame] | 186 | |
Daniel Rosenberg | 52b7768 | 2017-01-27 19:35:08 -0800 | [diff] [blame] | 187 | if (!qstr_copy(key, &ret->key)) { |
Daniel Rosenberg | fbd34b6 | 2016-05-10 13:42:43 -0700 | [diff] [blame] | 188 | kmem_cache_free(hashtable_entry_cachep, ret); |
| 189 | return NULL; |
| 190 | } |
| 191 | |
| 192 | atomic_set(&ret->value, value); |
| 193 | return ret; |
| 194 | } |
| 195 | |
Daniel Rosenberg | 52b7768 | 2017-01-27 19:35:08 -0800 | [diff] [blame] | 196 | static int insert_packagelist_appid_entry_locked(const struct qstr *key, appid_t value) |
Daniel Campello | 5d3b416 | 2015-07-20 16:33:46 -0700 | [diff] [blame] | 197 | { |
Daniel Campello | 35c9e24 | 2015-07-20 16:23:50 -0700 | [diff] [blame] | 198 | struct hashtable_entry *hash_cur; |
| 199 | struct hashtable_entry *new_entry; |
Daniel Rosenberg | 52b7768 | 2017-01-27 19:35:08 -0800 | [diff] [blame] | 200 | unsigned int hash = key->hash; |
Daniel Campello | 35c9e24 | 2015-07-20 16:23:50 -0700 | [diff] [blame] | 201 | |
Daniel Rosenberg | fbd34b6 | 2016-05-10 13:42:43 -0700 | [diff] [blame] | 202 | hash_for_each_possible_rcu(package_to_appid, hash_cur, hlist, hash) { |
Daniel Rosenberg | 5004c5f | 2017-01-31 20:07:51 -0800 | [diff] [blame] | 203 | if (qstr_case_eq(key, &hash_cur->key)) { |
Daniel Rosenberg | fbd34b6 | 2016-05-10 13:42:43 -0700 | [diff] [blame] | 204 | atomic_set(&hash_cur->value, value); |
Daniel Campello | 35c9e24 | 2015-07-20 16:23:50 -0700 | [diff] [blame] | 205 | return 0; |
| 206 | } |
| 207 | } |
Daniel Rosenberg | ad90525 | 2017-01-25 13:48:45 -0800 | [diff] [blame] | 208 | new_entry = alloc_hashtable_entry(key, value); |
Daniel Campello | 35c9e24 | 2015-07-20 16:23:50 -0700 | [diff] [blame] | 209 | if (!new_entry) |
| 210 | return -ENOMEM; |
Daniel Rosenberg | fbd34b6 | 2016-05-10 13:42:43 -0700 | [diff] [blame] | 211 | hash_add_rcu(package_to_appid, &new_entry->hlist, hash); |
Daniel Campello | 35c9e24 | 2015-07-20 16:23:50 -0700 | [diff] [blame] | 212 | return 0; |
| 213 | } |
| 214 | |
Daniel Rosenberg | 52b7768 | 2017-01-27 19:35:08 -0800 | [diff] [blame] | 215 | static int insert_ext_gid_entry_locked(const struct qstr *key, appid_t value) |
Daniel Rosenberg | ad90525 | 2017-01-25 13:48:45 -0800 | [diff] [blame] | 216 | { |
| 217 | struct hashtable_entry *hash_cur; |
| 218 | struct hashtable_entry *new_entry; |
Daniel Rosenberg | 52b7768 | 2017-01-27 19:35:08 -0800 | [diff] [blame] | 219 | unsigned int hash = key->hash; |
Daniel Rosenberg | ad90525 | 2017-01-25 13:48:45 -0800 | [diff] [blame] | 220 | |
| 221 | /* An extension can only belong to one gid */ |
| 222 | hash_for_each_possible_rcu(ext_to_groupid, hash_cur, hlist, hash) { |
Daniel Rosenberg | 5004c5f | 2017-01-31 20:07:51 -0800 | [diff] [blame] | 223 | if (qstr_case_eq(key, &hash_cur->key)) |
Daniel Rosenberg | ad90525 | 2017-01-25 13:48:45 -0800 | [diff] [blame] | 224 | return -EINVAL; |
| 225 | } |
| 226 | new_entry = alloc_hashtable_entry(key, value); |
| 227 | if (!new_entry) |
| 228 | return -ENOMEM; |
| 229 | hash_add_rcu(ext_to_groupid, &new_entry->hlist, hash); |
| 230 | return 0; |
| 231 | } |
| 232 | |
Daniel Rosenberg | 52b7768 | 2017-01-27 19:35:08 -0800 | [diff] [blame] | 233 | static int insert_userid_exclude_entry_locked(const struct qstr *key, userid_t value) |
Daniel Rosenberg | d8caaf9 | 2017-01-22 15:32:49 -0800 | [diff] [blame] | 234 | { |
| 235 | struct hashtable_entry *hash_cur; |
| 236 | struct hashtable_entry *new_entry; |
Daniel Rosenberg | 52b7768 | 2017-01-27 19:35:08 -0800 | [diff] [blame] | 237 | unsigned int hash = key->hash; |
Daniel Rosenberg | d8caaf9 | 2017-01-22 15:32:49 -0800 | [diff] [blame] | 238 | |
| 239 | /* Only insert if not already present */ |
| 240 | hash_for_each_possible_rcu(package_to_userid, hash_cur, hlist, hash) { |
Daniel Rosenberg | 52b7768 | 2017-01-27 19:35:08 -0800 | [diff] [blame] | 241 | if (atomic_read(&hash_cur->value) == value && |
Daniel Rosenberg | 5004c5f | 2017-01-31 20:07:51 -0800 | [diff] [blame] | 242 | qstr_case_eq(key, &hash_cur->key)) |
Daniel Rosenberg | d8caaf9 | 2017-01-22 15:32:49 -0800 | [diff] [blame] | 243 | return 0; |
| 244 | } |
Daniel Rosenberg | ad90525 | 2017-01-25 13:48:45 -0800 | [diff] [blame] | 245 | new_entry = alloc_hashtable_entry(key, value); |
Daniel Rosenberg | d8caaf9 | 2017-01-22 15:32:49 -0800 | [diff] [blame] | 246 | if (!new_entry) |
| 247 | return -ENOMEM; |
| 248 | hash_add_rcu(package_to_userid, &new_entry->hlist, hash); |
| 249 | return 0; |
| 250 | } |
| 251 | |
Daniel Rosenberg | 52b7768 | 2017-01-27 19:35:08 -0800 | [diff] [blame] | 252 | static void fixup_all_perms_name(const struct qstr *key) |
Daniel Rosenberg | d8caaf9 | 2017-01-22 15:32:49 -0800 | [diff] [blame] | 253 | { |
| 254 | struct sdcardfs_sb_info *sbinfo; |
| 255 | struct limit_search limit = { |
| 256 | .flags = BY_NAME, |
Daniel Rosenberg | 721274a | 2017-03-08 17:20:02 -0800 | [diff] [blame] | 257 | .name = QSTR_INIT(key->name, key->len), |
Daniel Rosenberg | d8caaf9 | 2017-01-22 15:32:49 -0800 | [diff] [blame] | 258 | }; |
| 259 | list_for_each_entry(sbinfo, &sdcardfs_super_list, list) { |
| 260 | if (sbinfo_has_sdcard_magic(sbinfo)) |
| 261 | fixup_perms_recursive(sbinfo->sb->s_root, &limit); |
Daniel Rosenberg | 497ac90 | 2016-02-03 21:08:21 -0800 | [diff] [blame] | 262 | } |
Daniel Campello | 35c9e24 | 2015-07-20 16:23:50 -0700 | [diff] [blame] | 263 | } |
| 264 | |
Daniel Rosenberg | 52b7768 | 2017-01-27 19:35:08 -0800 | [diff] [blame] | 265 | static void fixup_all_perms_name_userid(const struct qstr *key, userid_t userid) |
Daniel Rosenberg | 497ac90 | 2016-02-03 21:08:21 -0800 | [diff] [blame] | 266 | { |
| 267 | struct sdcardfs_sb_info *sbinfo; |
Daniel Rosenberg | d8caaf9 | 2017-01-22 15:32:49 -0800 | [diff] [blame] | 268 | struct limit_search limit = { |
| 269 | .flags = BY_NAME | BY_USERID, |
Daniel Rosenberg | 721274a | 2017-03-08 17:20:02 -0800 | [diff] [blame] | 270 | .name = QSTR_INIT(key->name, key->len), |
Daniel Rosenberg | d8caaf9 | 2017-01-22 15:32:49 -0800 | [diff] [blame] | 271 | .userid = userid, |
| 272 | }; |
| 273 | list_for_each_entry(sbinfo, &sdcardfs_super_list, list) { |
| 274 | if (sbinfo_has_sdcard_magic(sbinfo)) |
| 275 | fixup_perms_recursive(sbinfo->sb->s_root, &limit); |
| 276 | } |
| 277 | } |
| 278 | |
| 279 | static void fixup_all_perms_userid(userid_t userid) |
| 280 | { |
| 281 | struct sdcardfs_sb_info *sbinfo; |
| 282 | struct limit_search limit = { |
| 283 | .flags = BY_USERID, |
| 284 | .userid = userid, |
| 285 | }; |
| 286 | list_for_each_entry(sbinfo, &sdcardfs_super_list, list) { |
| 287 | if (sbinfo_has_sdcard_magic(sbinfo)) |
| 288 | fixup_perms_recursive(sbinfo->sb->s_root, &limit); |
| 289 | } |
Daniel Rosenberg | fbd34b6 | 2016-05-10 13:42:43 -0700 | [diff] [blame] | 290 | } |
| 291 | |
Daniel Rosenberg | 52b7768 | 2017-01-27 19:35:08 -0800 | [diff] [blame] | 292 | static int insert_packagelist_entry(const struct qstr *key, appid_t value) |
Daniel Rosenberg | fbd34b6 | 2016-05-10 13:42:43 -0700 | [diff] [blame] | 293 | { |
| 294 | int err; |
| 295 | |
| 296 | mutex_lock(&sdcardfs_super_list_lock); |
Daniel Rosenberg | d8caaf9 | 2017-01-22 15:32:49 -0800 | [diff] [blame] | 297 | err = insert_packagelist_appid_entry_locked(key, value); |
Daniel Rosenberg | fbd34b6 | 2016-05-10 13:42:43 -0700 | [diff] [blame] | 298 | if (!err) |
Daniel Rosenberg | d8caaf9 | 2017-01-22 15:32:49 -0800 | [diff] [blame] | 299 | fixup_all_perms_name(key); |
| 300 | mutex_unlock(&sdcardfs_super_list_lock); |
| 301 | |
| 302 | return err; |
| 303 | } |
| 304 | |
Daniel Rosenberg | 52b7768 | 2017-01-27 19:35:08 -0800 | [diff] [blame] | 305 | static int insert_ext_gid_entry(const struct qstr *key, appid_t value) |
Daniel Rosenberg | ad90525 | 2017-01-25 13:48:45 -0800 | [diff] [blame] | 306 | { |
| 307 | int err; |
| 308 | |
| 309 | mutex_lock(&sdcardfs_super_list_lock); |
| 310 | err = insert_ext_gid_entry_locked(key, value); |
| 311 | mutex_unlock(&sdcardfs_super_list_lock); |
| 312 | |
| 313 | return err; |
| 314 | } |
| 315 | |
Daniel Rosenberg | 52b7768 | 2017-01-27 19:35:08 -0800 | [diff] [blame] | 316 | static int insert_userid_exclude_entry(const struct qstr *key, userid_t value) |
Daniel Rosenberg | d8caaf9 | 2017-01-22 15:32:49 -0800 | [diff] [blame] | 317 | { |
| 318 | int err; |
| 319 | |
| 320 | mutex_lock(&sdcardfs_super_list_lock); |
| 321 | err = insert_userid_exclude_entry_locked(key, value); |
| 322 | if (!err) |
| 323 | fixup_all_perms_name_userid(key, value); |
Daniel Rosenberg | fbd34b6 | 2016-05-10 13:42:43 -0700 | [diff] [blame] | 324 | mutex_unlock(&sdcardfs_super_list_lock); |
| 325 | |
| 326 | return err; |
| 327 | } |
| 328 | |
Daniel Rosenberg | ad90525 | 2017-01-25 13:48:45 -0800 | [diff] [blame] | 329 | static void free_hashtable_entry(struct hashtable_entry *entry) |
Daniel Rosenberg | fbd34b6 | 2016-05-10 13:42:43 -0700 | [diff] [blame] | 330 | { |
Daniel Rosenberg | 52b7768 | 2017-01-27 19:35:08 -0800 | [diff] [blame] | 331 | kfree(entry->key.name); |
Daniel Rosenberg | fbd34b6 | 2016-05-10 13:42:43 -0700 | [diff] [blame] | 332 | kmem_cache_free(hashtable_entry_cachep, entry); |
| 333 | } |
| 334 | |
Daniel Rosenberg | 52b7768 | 2017-01-27 19:35:08 -0800 | [diff] [blame] | 335 | static void remove_packagelist_entry_locked(const struct qstr *key) |
Daniel Rosenberg | fbd34b6 | 2016-05-10 13:42:43 -0700 | [diff] [blame] | 336 | { |
Daniel Rosenberg | 497ac90 | 2016-02-03 21:08:21 -0800 | [diff] [blame] | 337 | struct hashtable_entry *hash_cur; |
Daniel Rosenberg | 52b7768 | 2017-01-27 19:35:08 -0800 | [diff] [blame] | 338 | unsigned int hash = key->hash; |
Daniel Rosenberg | d8caaf9 | 2017-01-22 15:32:49 -0800 | [diff] [blame] | 339 | struct hlist_node *h_t; |
| 340 | HLIST_HEAD(free_list); |
Daniel Rosenberg | fbd34b6 | 2016-05-10 13:42:43 -0700 | [diff] [blame] | 341 | |
Daniel Rosenberg | d8caaf9 | 2017-01-22 15:32:49 -0800 | [diff] [blame] | 342 | hash_for_each_possible_rcu(package_to_userid, hash_cur, hlist, hash) { |
Daniel Rosenberg | 5004c5f | 2017-01-31 20:07:51 -0800 | [diff] [blame] | 343 | if (qstr_case_eq(key, &hash_cur->key)) { |
Daniel Rosenberg | d8caaf9 | 2017-01-22 15:32:49 -0800 | [diff] [blame] | 344 | hash_del_rcu(&hash_cur->hlist); |
| 345 | hlist_add_head(&hash_cur->dlist, &free_list); |
| 346 | } |
| 347 | } |
Daniel Rosenberg | fbd34b6 | 2016-05-10 13:42:43 -0700 | [diff] [blame] | 348 | hash_for_each_possible_rcu(package_to_appid, hash_cur, hlist, hash) { |
Daniel Rosenberg | 5004c5f | 2017-01-31 20:07:51 -0800 | [diff] [blame] | 349 | if (qstr_case_eq(key, &hash_cur->key)) { |
Daniel Rosenberg | fbd34b6 | 2016-05-10 13:42:43 -0700 | [diff] [blame] | 350 | hash_del_rcu(&hash_cur->hlist); |
Daniel Rosenberg | d8caaf9 | 2017-01-22 15:32:49 -0800 | [diff] [blame] | 351 | hlist_add_head(&hash_cur->dlist, &free_list); |
| 352 | break; |
Daniel Rosenberg | 497ac90 | 2016-02-03 21:08:21 -0800 | [diff] [blame] | 353 | } |
| 354 | } |
Daniel Rosenberg | d8caaf9 | 2017-01-22 15:32:49 -0800 | [diff] [blame] | 355 | synchronize_rcu(); |
| 356 | hlist_for_each_entry_safe(hash_cur, h_t, &free_list, dlist) |
Daniel Rosenberg | ad90525 | 2017-01-25 13:48:45 -0800 | [diff] [blame] | 357 | free_hashtable_entry(hash_cur); |
Daniel Rosenberg | fbd34b6 | 2016-05-10 13:42:43 -0700 | [diff] [blame] | 358 | } |
| 359 | |
Daniel Rosenberg | 52b7768 | 2017-01-27 19:35:08 -0800 | [diff] [blame] | 360 | static void remove_packagelist_entry(const struct qstr *key) |
Daniel Rosenberg | fbd34b6 | 2016-05-10 13:42:43 -0700 | [diff] [blame] | 361 | { |
| 362 | mutex_lock(&sdcardfs_super_list_lock); |
| 363 | remove_packagelist_entry_locked(key); |
Daniel Rosenberg | d8caaf9 | 2017-01-22 15:32:49 -0800 | [diff] [blame] | 364 | fixup_all_perms_name(key); |
| 365 | mutex_unlock(&sdcardfs_super_list_lock); |
Daniel Rosenberg | d8caaf9 | 2017-01-22 15:32:49 -0800 | [diff] [blame] | 366 | } |
| 367 | |
Daniel Rosenberg | 52b7768 | 2017-01-27 19:35:08 -0800 | [diff] [blame] | 368 | static void remove_ext_gid_entry_locked(const struct qstr *key, gid_t group) |
Daniel Rosenberg | ad90525 | 2017-01-25 13:48:45 -0800 | [diff] [blame] | 369 | { |
| 370 | struct hashtable_entry *hash_cur; |
Daniel Rosenberg | 52b7768 | 2017-01-27 19:35:08 -0800 | [diff] [blame] | 371 | unsigned int hash = key->hash; |
Daniel Rosenberg | ad90525 | 2017-01-25 13:48:45 -0800 | [diff] [blame] | 372 | |
| 373 | hash_for_each_possible_rcu(ext_to_groupid, hash_cur, hlist, hash) { |
Daniel Rosenberg | 5004c5f | 2017-01-31 20:07:51 -0800 | [diff] [blame] | 374 | if (qstr_case_eq(key, &hash_cur->key) && atomic_read(&hash_cur->value) == group) { |
Daniel Rosenberg | ad90525 | 2017-01-25 13:48:45 -0800 | [diff] [blame] | 375 | hash_del_rcu(&hash_cur->hlist); |
| 376 | synchronize_rcu(); |
| 377 | free_hashtable_entry(hash_cur); |
| 378 | break; |
| 379 | } |
| 380 | } |
| 381 | } |
| 382 | |
Daniel Rosenberg | 52b7768 | 2017-01-27 19:35:08 -0800 | [diff] [blame] | 383 | static void remove_ext_gid_entry(const struct qstr *key, gid_t group) |
Daniel Rosenberg | ad90525 | 2017-01-25 13:48:45 -0800 | [diff] [blame] | 384 | { |
| 385 | mutex_lock(&sdcardfs_super_list_lock); |
| 386 | remove_ext_gid_entry_locked(key, group); |
| 387 | mutex_unlock(&sdcardfs_super_list_lock); |
Daniel Rosenberg | ad90525 | 2017-01-25 13:48:45 -0800 | [diff] [blame] | 388 | } |
| 389 | |
Daniel Rosenberg | d8caaf9 | 2017-01-22 15:32:49 -0800 | [diff] [blame] | 390 | static void remove_userid_all_entry_locked(userid_t userid) |
| 391 | { |
| 392 | struct hashtable_entry *hash_cur; |
| 393 | struct hlist_node *h_t; |
| 394 | HLIST_HEAD(free_list); |
| 395 | int i; |
| 396 | |
| 397 | hash_for_each_rcu(package_to_userid, i, hash_cur, hlist) { |
| 398 | if (atomic_read(&hash_cur->value) == userid) { |
| 399 | hash_del_rcu(&hash_cur->hlist); |
| 400 | hlist_add_head(&hash_cur->dlist, &free_list); |
| 401 | } |
| 402 | } |
| 403 | synchronize_rcu(); |
| 404 | hlist_for_each_entry_safe(hash_cur, h_t, &free_list, dlist) { |
Daniel Rosenberg | ad90525 | 2017-01-25 13:48:45 -0800 | [diff] [blame] | 405 | free_hashtable_entry(hash_cur); |
Daniel Rosenberg | d8caaf9 | 2017-01-22 15:32:49 -0800 | [diff] [blame] | 406 | } |
| 407 | } |
| 408 | |
| 409 | static void remove_userid_all_entry(userid_t userid) |
| 410 | { |
| 411 | mutex_lock(&sdcardfs_super_list_lock); |
| 412 | remove_userid_all_entry_locked(userid); |
| 413 | fixup_all_perms_userid(userid); |
| 414 | mutex_unlock(&sdcardfs_super_list_lock); |
Daniel Rosenberg | d8caaf9 | 2017-01-22 15:32:49 -0800 | [diff] [blame] | 415 | } |
| 416 | |
Daniel Rosenberg | 52b7768 | 2017-01-27 19:35:08 -0800 | [diff] [blame] | 417 | static void remove_userid_exclude_entry_locked(const struct qstr *key, userid_t userid) |
Daniel Rosenberg | d8caaf9 | 2017-01-22 15:32:49 -0800 | [diff] [blame] | 418 | { |
| 419 | struct hashtable_entry *hash_cur; |
Daniel Rosenberg | 52b7768 | 2017-01-27 19:35:08 -0800 | [diff] [blame] | 420 | unsigned int hash = key->hash; |
Daniel Rosenberg | d8caaf9 | 2017-01-22 15:32:49 -0800 | [diff] [blame] | 421 | |
| 422 | hash_for_each_possible_rcu(package_to_userid, hash_cur, hlist, hash) { |
Daniel Rosenberg | 5004c5f | 2017-01-31 20:07:51 -0800 | [diff] [blame] | 423 | if (qstr_case_eq(key, &hash_cur->key) && |
Daniel Rosenberg | 52b7768 | 2017-01-27 19:35:08 -0800 | [diff] [blame] | 424 | atomic_read(&hash_cur->value) == userid) { |
Daniel Rosenberg | d8caaf9 | 2017-01-22 15:32:49 -0800 | [diff] [blame] | 425 | hash_del_rcu(&hash_cur->hlist); |
| 426 | synchronize_rcu(); |
Daniel Rosenberg | ad90525 | 2017-01-25 13:48:45 -0800 | [diff] [blame] | 427 | free_hashtable_entry(hash_cur); |
Daniel Rosenberg | d8caaf9 | 2017-01-22 15:32:49 -0800 | [diff] [blame] | 428 | break; |
| 429 | } |
| 430 | } |
| 431 | } |
| 432 | |
Daniel Rosenberg | 52b7768 | 2017-01-27 19:35:08 -0800 | [diff] [blame] | 433 | static void remove_userid_exclude_entry(const struct qstr *key, userid_t userid) |
Daniel Rosenberg | d8caaf9 | 2017-01-22 15:32:49 -0800 | [diff] [blame] | 434 | { |
| 435 | mutex_lock(&sdcardfs_super_list_lock); |
| 436 | remove_userid_exclude_entry_locked(key, userid); |
| 437 | fixup_all_perms_name_userid(key, userid); |
Daniel Rosenberg | 497ac90 | 2016-02-03 21:08:21 -0800 | [diff] [blame] | 438 | mutex_unlock(&sdcardfs_super_list_lock); |
Daniel Rosenberg | 497ac90 | 2016-02-03 21:08:21 -0800 | [diff] [blame] | 439 | } |
| 440 | |
Daniel Rosenberg | fbd34b6 | 2016-05-10 13:42:43 -0700 | [diff] [blame] | 441 | static void packagelist_destroy(void) |
Daniel Campello | 35c9e24 | 2015-07-20 16:23:50 -0700 | [diff] [blame] | 442 | { |
| 443 | struct hashtable_entry *hash_cur; |
Daniel Campello | 35c9e24 | 2015-07-20 16:23:50 -0700 | [diff] [blame] | 444 | struct hlist_node *h_t; |
Daniel Rosenberg | fbd34b6 | 2016-05-10 13:42:43 -0700 | [diff] [blame] | 445 | HLIST_HEAD(free_list); |
Daniel Campello | 35c9e24 | 2015-07-20 16:23:50 -0700 | [diff] [blame] | 446 | int i; |
Daniel Rosenberg | 5e024f6 | 2017-03-16 17:42:58 -0700 | [diff] [blame] | 447 | |
Daniel Rosenberg | fbd34b6 | 2016-05-10 13:42:43 -0700 | [diff] [blame] | 448 | mutex_lock(&sdcardfs_super_list_lock); |
| 449 | hash_for_each_rcu(package_to_appid, i, hash_cur, hlist) { |
| 450 | hash_del_rcu(&hash_cur->hlist); |
Daniel Rosenberg | d8caaf9 | 2017-01-22 15:32:49 -0800 | [diff] [blame] | 451 | hlist_add_head(&hash_cur->dlist, &free_list); |
| 452 | } |
| 453 | hash_for_each_rcu(package_to_userid, i, hash_cur, hlist) { |
| 454 | hash_del_rcu(&hash_cur->hlist); |
| 455 | hlist_add_head(&hash_cur->dlist, &free_list); |
Daniel Campello | 35c9e24 | 2015-07-20 16:23:50 -0700 | [diff] [blame] | 456 | } |
Daniel Rosenberg | fbd34b6 | 2016-05-10 13:42:43 -0700 | [diff] [blame] | 457 | synchronize_rcu(); |
Daniel Rosenberg | d8caaf9 | 2017-01-22 15:32:49 -0800 | [diff] [blame] | 458 | hlist_for_each_entry_safe(hash_cur, h_t, &free_list, dlist) |
Daniel Rosenberg | ad90525 | 2017-01-25 13:48:45 -0800 | [diff] [blame] | 459 | free_hashtable_entry(hash_cur); |
Daniel Rosenberg | fbd34b6 | 2016-05-10 13:42:43 -0700 | [diff] [blame] | 460 | mutex_unlock(&sdcardfs_super_list_lock); |
Daniel Rosenberg | 77ecf21 | 2017-03-16 17:46:13 -0700 | [diff] [blame] | 461 | pr_info("sdcardfs: destroyed packagelist pkgld\n"); |
Daniel Campello | 35c9e24 | 2015-07-20 16:23:50 -0700 | [diff] [blame] | 462 | } |
| 463 | |
Daniel Rosenberg | d8caaf9 | 2017-01-22 15:32:49 -0800 | [diff] [blame] | 464 | #define SDCARDFS_CONFIGFS_ATTR(_pfx, _name) \ |
| 465 | static struct configfs_attribute _pfx##attr_##_name = { \ |
| 466 | .ca_name = __stringify(_name), \ |
| 467 | .ca_mode = S_IRUGO | S_IWUGO, \ |
| 468 | .ca_owner = THIS_MODULE, \ |
| 469 | .show = _pfx##_name##_show, \ |
| 470 | .store = _pfx##_name##_store, \ |
| 471 | } |
| 472 | |
| 473 | #define SDCARDFS_CONFIGFS_ATTR_RO(_pfx, _name) \ |
| 474 | static struct configfs_attribute _pfx##attr_##_name = { \ |
| 475 | .ca_name = __stringify(_name), \ |
| 476 | .ca_mode = S_IRUGO, \ |
| 477 | .ca_owner = THIS_MODULE, \ |
| 478 | .show = _pfx##_name##_show, \ |
| 479 | } |
| 480 | |
| 481 | #define SDCARDFS_CONFIGFS_ATTR_WO(_pfx, _name) \ |
| 482 | static struct configfs_attribute _pfx##attr_##_name = { \ |
| 483 | .ca_name = __stringify(_name), \ |
| 484 | .ca_mode = S_IWUGO, \ |
| 485 | .ca_owner = THIS_MODULE, \ |
| 486 | .store = _pfx##_name##_store, \ |
| 487 | } |
| 488 | |
Daniel Rosenberg | f48ace1 | 2017-01-21 00:35:26 -0800 | [diff] [blame] | 489 | struct package_details { |
Daniel Rosenberg | 497ac90 | 2016-02-03 21:08:21 -0800 | [diff] [blame] | 490 | struct config_item item; |
Daniel Rosenberg | 52b7768 | 2017-01-27 19:35:08 -0800 | [diff] [blame] | 491 | struct qstr name; |
Daniel Rosenberg | 497ac90 | 2016-02-03 21:08:21 -0800 | [diff] [blame] | 492 | }; |
| 493 | |
Daniel Rosenberg | f48ace1 | 2017-01-21 00:35:26 -0800 | [diff] [blame] | 494 | static inline struct package_details *to_package_details(struct config_item *item) |
Daniel Rosenberg | 497ac90 | 2016-02-03 21:08:21 -0800 | [diff] [blame] | 495 | { |
Daniel Rosenberg | f48ace1 | 2017-01-21 00:35:26 -0800 | [diff] [blame] | 496 | return item ? container_of(item, struct package_details, item) : NULL; |
Daniel Rosenberg | 497ac90 | 2016-02-03 21:08:21 -0800 | [diff] [blame] | 497 | } |
| 498 | |
Daniel Rosenberg | f48ace1 | 2017-01-21 00:35:26 -0800 | [diff] [blame] | 499 | static ssize_t package_details_appid_show(struct config_item *item, char *page) |
Daniel Rosenberg | 497ac90 | 2016-02-03 21:08:21 -0800 | [diff] [blame] | 500 | { |
Daniel Rosenberg | 52b7768 | 2017-01-27 19:35:08 -0800 | [diff] [blame] | 501 | return scnprintf(page, PAGE_SIZE, "%u\n", __get_appid(&to_package_details(item)->name)); |
Daniel Rosenberg | 497ac90 | 2016-02-03 21:08:21 -0800 | [diff] [blame] | 502 | } |
| 503 | |
Daniel Rosenberg | f48ace1 | 2017-01-21 00:35:26 -0800 | [diff] [blame] | 504 | static ssize_t package_details_appid_store(struct config_item *item, |
Daniel Rosenberg | 497ac90 | 2016-02-03 21:08:21 -0800 | [diff] [blame] | 505 | const char *page, size_t count) |
| 506 | { |
Daniel Rosenberg | fbd34b6 | 2016-05-10 13:42:43 -0700 | [diff] [blame] | 507 | unsigned int tmp; |
Daniel Rosenberg | 497ac90 | 2016-02-03 21:08:21 -0800 | [diff] [blame] | 508 | int ret; |
| 509 | |
Daniel Rosenberg | fbd34b6 | 2016-05-10 13:42:43 -0700 | [diff] [blame] | 510 | ret = kstrtouint(page, 10, &tmp); |
| 511 | if (ret) |
| 512 | return ret; |
Daniel Rosenberg | 497ac90 | 2016-02-03 21:08:21 -0800 | [diff] [blame] | 513 | |
Daniel Rosenberg | 52b7768 | 2017-01-27 19:35:08 -0800 | [diff] [blame] | 514 | ret = insert_packagelist_entry(&to_package_details(item)->name, tmp); |
Daniel Rosenberg | f48ace1 | 2017-01-21 00:35:26 -0800 | [diff] [blame] | 515 | |
Daniel Rosenberg | 497ac90 | 2016-02-03 21:08:21 -0800 | [diff] [blame] | 516 | if (ret) |
| 517 | return ret; |
| 518 | |
| 519 | return count; |
| 520 | } |
| 521 | |
Daniel Rosenberg | d8caaf9 | 2017-01-22 15:32:49 -0800 | [diff] [blame] | 522 | static ssize_t package_details_excluded_userids_show(struct config_item *item, |
| 523 | char *page) |
| 524 | { |
| 525 | struct package_details *package_details = to_package_details(item); |
| 526 | struct hashtable_entry *hash_cur; |
Daniel Rosenberg | 52b7768 | 2017-01-27 19:35:08 -0800 | [diff] [blame] | 527 | unsigned int hash = package_details->name.hash; |
Daniel Rosenberg | d8caaf9 | 2017-01-22 15:32:49 -0800 | [diff] [blame] | 528 | int count = 0; |
| 529 | |
| 530 | rcu_read_lock(); |
| 531 | hash_for_each_possible_rcu(package_to_userid, hash_cur, hlist, hash) { |
Daniel Rosenberg | 5004c5f | 2017-01-31 20:07:51 -0800 | [diff] [blame] | 532 | if (qstr_case_eq(&package_details->name, &hash_cur->key)) |
Daniel Rosenberg | d8caaf9 | 2017-01-22 15:32:49 -0800 | [diff] [blame] | 533 | count += scnprintf(page + count, PAGE_SIZE - count, |
| 534 | "%d ", atomic_read(&hash_cur->value)); |
| 535 | } |
| 536 | rcu_read_unlock(); |
| 537 | if (count) |
| 538 | count--; |
| 539 | count += scnprintf(page + count, PAGE_SIZE - count, "\n"); |
| 540 | return count; |
| 541 | } |
| 542 | |
| 543 | static ssize_t package_details_excluded_userids_store(struct config_item *item, |
| 544 | const char *page, size_t count) |
| 545 | { |
| 546 | unsigned int tmp; |
| 547 | int ret; |
| 548 | |
| 549 | ret = kstrtouint(page, 10, &tmp); |
| 550 | if (ret) |
| 551 | return ret; |
| 552 | |
Daniel Rosenberg | 52b7768 | 2017-01-27 19:35:08 -0800 | [diff] [blame] | 553 | ret = insert_userid_exclude_entry(&to_package_details(item)->name, tmp); |
Daniel Rosenberg | d8caaf9 | 2017-01-22 15:32:49 -0800 | [diff] [blame] | 554 | |
| 555 | if (ret) |
| 556 | return ret; |
| 557 | |
| 558 | return count; |
| 559 | } |
| 560 | |
| 561 | static ssize_t package_details_clear_userid_store(struct config_item *item, |
| 562 | const char *page, size_t count) |
| 563 | { |
| 564 | unsigned int tmp; |
| 565 | int ret; |
| 566 | |
| 567 | ret = kstrtouint(page, 10, &tmp); |
| 568 | if (ret) |
| 569 | return ret; |
Daniel Rosenberg | 52b7768 | 2017-01-27 19:35:08 -0800 | [diff] [blame] | 570 | remove_userid_exclude_entry(&to_package_details(item)->name, tmp); |
Daniel Rosenberg | d8caaf9 | 2017-01-22 15:32:49 -0800 | [diff] [blame] | 571 | return count; |
| 572 | } |
| 573 | |
Daniel Rosenberg | f48ace1 | 2017-01-21 00:35:26 -0800 | [diff] [blame] | 574 | static void package_details_release(struct config_item *item) |
| 575 | { |
| 576 | struct package_details *package_details = to_package_details(item); |
Daniel Rosenberg | 77ecf21 | 2017-03-16 17:46:13 -0700 | [diff] [blame] | 577 | |
| 578 | pr_info("sdcardfs: removing %s\n", package_details->name.name); |
Daniel Rosenberg | 52b7768 | 2017-01-27 19:35:08 -0800 | [diff] [blame] | 579 | remove_packagelist_entry(&package_details->name); |
| 580 | kfree(package_details->name.name); |
Daniel Rosenberg | f48ace1 | 2017-01-21 00:35:26 -0800 | [diff] [blame] | 581 | kfree(package_details); |
| 582 | } |
Daniel Rosenberg | 497ac90 | 2016-02-03 21:08:21 -0800 | [diff] [blame] | 583 | |
Daniel Rosenberg | d8caaf9 | 2017-01-22 15:32:49 -0800 | [diff] [blame] | 584 | SDCARDFS_CONFIGFS_ATTR(package_details_, appid); |
| 585 | SDCARDFS_CONFIGFS_ATTR(package_details_, excluded_userids); |
| 586 | SDCARDFS_CONFIGFS_ATTR_WO(package_details_, clear_userid); |
Daniel Rosenberg | f48ace1 | 2017-01-21 00:35:26 -0800 | [diff] [blame] | 587 | |
| 588 | static struct configfs_attribute *package_details_attrs[] = { |
| 589 | &package_details_attr_appid, |
Daniel Rosenberg | d8caaf9 | 2017-01-22 15:32:49 -0800 | [diff] [blame] | 590 | &package_details_attr_excluded_userids, |
| 591 | &package_details_attr_clear_userid, |
Daniel Rosenberg | 497ac90 | 2016-02-03 21:08:21 -0800 | [diff] [blame] | 592 | NULL, |
| 593 | }; |
| 594 | |
Daniel Rosenberg | f48ace1 | 2017-01-21 00:35:26 -0800 | [diff] [blame] | 595 | static struct configfs_item_operations package_details_item_ops = { |
Daniel Rosenberg | 5e024f6 | 2017-03-16 17:42:58 -0700 | [diff] [blame] | 596 | .release = package_details_release, |
Daniel Rosenberg | 497ac90 | 2016-02-03 21:08:21 -0800 | [diff] [blame] | 597 | }; |
| 598 | |
| 599 | static struct config_item_type package_appid_type = { |
Daniel Rosenberg | f48ace1 | 2017-01-21 00:35:26 -0800 | [diff] [blame] | 600 | .ct_item_ops = &package_details_item_ops, |
| 601 | .ct_attrs = package_details_attrs, |
Daniel Rosenberg | 497ac90 | 2016-02-03 21:08:21 -0800 | [diff] [blame] | 602 | .ct_owner = THIS_MODULE, |
| 603 | }; |
| 604 | |
Daniel Rosenberg | ad90525 | 2017-01-25 13:48:45 -0800 | [diff] [blame] | 605 | struct extensions_value { |
| 606 | struct config_group group; |
| 607 | unsigned int num; |
| 608 | }; |
| 609 | |
| 610 | struct extension_details { |
| 611 | struct config_item item; |
Daniel Rosenberg | 52b7768 | 2017-01-27 19:35:08 -0800 | [diff] [blame] | 612 | struct qstr name; |
Daniel Rosenberg | ad90525 | 2017-01-25 13:48:45 -0800 | [diff] [blame] | 613 | unsigned int num; |
| 614 | }; |
| 615 | |
| 616 | static inline struct extensions_value *to_extensions_value(struct config_item *item) |
| 617 | { |
| 618 | return item ? container_of(to_config_group(item), struct extensions_value, group) : NULL; |
| 619 | } |
| 620 | |
| 621 | static inline struct extension_details *to_extension_details(struct config_item *item) |
| 622 | { |
| 623 | return item ? container_of(item, struct extension_details, item) : NULL; |
| 624 | } |
| 625 | |
| 626 | static void extension_details_release(struct config_item *item) |
| 627 | { |
| 628 | struct extension_details *extension_details = to_extension_details(item); |
| 629 | |
Daniel Rosenberg | 77ecf21 | 2017-03-16 17:46:13 -0700 | [diff] [blame] | 630 | pr_info("sdcardfs: No longer mapping %s files to gid %d\n", |
Daniel Rosenberg | 52b7768 | 2017-01-27 19:35:08 -0800 | [diff] [blame] | 631 | extension_details->name.name, extension_details->num); |
| 632 | remove_ext_gid_entry(&extension_details->name, extension_details->num); |
| 633 | kfree(extension_details->name.name); |
Daniel Rosenberg | ad90525 | 2017-01-25 13:48:45 -0800 | [diff] [blame] | 634 | kfree(extension_details); |
| 635 | } |
| 636 | |
| 637 | static struct configfs_item_operations extension_details_item_ops = { |
| 638 | .release = extension_details_release, |
| 639 | }; |
| 640 | |
| 641 | static struct config_item_type extension_details_type = { |
| 642 | .ct_item_ops = &extension_details_item_ops, |
| 643 | .ct_owner = THIS_MODULE, |
| 644 | }; |
| 645 | |
| 646 | static struct config_item *extension_details_make_item(struct config_group *group, const char *name) |
| 647 | { |
| 648 | struct extensions_value *extensions_value = to_extensions_value(&group->cg_item); |
| 649 | struct extension_details *extension_details = kzalloc(sizeof(struct extension_details), GFP_KERNEL); |
Daniel Rosenberg | 52b7768 | 2017-01-27 19:35:08 -0800 | [diff] [blame] | 650 | const char *tmp; |
Daniel Rosenberg | ad90525 | 2017-01-25 13:48:45 -0800 | [diff] [blame] | 651 | int ret; |
Daniel Rosenberg | 5e024f6 | 2017-03-16 17:42:58 -0700 | [diff] [blame] | 652 | |
Daniel Rosenberg | ad90525 | 2017-01-25 13:48:45 -0800 | [diff] [blame] | 653 | if (!extension_details) |
| 654 | return ERR_PTR(-ENOMEM); |
| 655 | |
Daniel Rosenberg | 52b7768 | 2017-01-27 19:35:08 -0800 | [diff] [blame] | 656 | tmp = kstrdup(name, GFP_KERNEL); |
| 657 | if (!tmp) { |
Daniel Rosenberg | ad90525 | 2017-01-25 13:48:45 -0800 | [diff] [blame] | 658 | kfree(extension_details); |
| 659 | return ERR_PTR(-ENOMEM); |
| 660 | } |
Daniel Rosenberg | 52b7768 | 2017-01-27 19:35:08 -0800 | [diff] [blame] | 661 | qstr_init(&extension_details->name, tmp); |
Ritesh Harjani | e7f51a5 | 2017-12-04 09:51:07 +0530 | [diff] [blame] | 662 | extension_details->num = extensions_value->num; |
Daniel Rosenberg | 52b7768 | 2017-01-27 19:35:08 -0800 | [diff] [blame] | 663 | ret = insert_ext_gid_entry(&extension_details->name, extensions_value->num); |
Daniel Rosenberg | ad90525 | 2017-01-25 13:48:45 -0800 | [diff] [blame] | 664 | |
| 665 | if (ret) { |
Daniel Rosenberg | 52b7768 | 2017-01-27 19:35:08 -0800 | [diff] [blame] | 666 | kfree(extension_details->name.name); |
Daniel Rosenberg | ad90525 | 2017-01-25 13:48:45 -0800 | [diff] [blame] | 667 | kfree(extension_details); |
| 668 | return ERR_PTR(ret); |
| 669 | } |
| 670 | config_item_init_type_name(&extension_details->item, name, &extension_details_type); |
| 671 | |
| 672 | return &extension_details->item; |
| 673 | } |
| 674 | |
| 675 | static struct configfs_group_operations extensions_value_group_ops = { |
| 676 | .make_item = extension_details_make_item, |
| 677 | }; |
| 678 | |
| 679 | static struct config_item_type extensions_name_type = { |
| 680 | .ct_group_ops = &extensions_value_group_ops, |
| 681 | .ct_owner = THIS_MODULE, |
| 682 | }; |
| 683 | |
| 684 | static struct config_group *extensions_make_group(struct config_group *group, const char *name) |
| 685 | { |
| 686 | struct extensions_value *extensions_value; |
| 687 | unsigned int tmp; |
| 688 | int ret; |
| 689 | |
| 690 | extensions_value = kzalloc(sizeof(struct extensions_value), GFP_KERNEL); |
| 691 | if (!extensions_value) |
| 692 | return ERR_PTR(-ENOMEM); |
| 693 | ret = kstrtouint(name, 10, &tmp); |
| 694 | if (ret) { |
| 695 | kfree(extensions_value); |
| 696 | return ERR_PTR(ret); |
| 697 | } |
| 698 | |
| 699 | extensions_value->num = tmp; |
| 700 | config_group_init_type_name(&extensions_value->group, name, |
| 701 | &extensions_name_type); |
| 702 | return &extensions_value->group; |
| 703 | } |
| 704 | |
| 705 | static void extensions_drop_group(struct config_group *group, struct config_item *item) |
| 706 | { |
| 707 | struct extensions_value *value = to_extensions_value(item); |
Daniel Rosenberg | 5e024f6 | 2017-03-16 17:42:58 -0700 | [diff] [blame] | 708 | |
Daniel Rosenberg | 77ecf21 | 2017-03-16 17:46:13 -0700 | [diff] [blame] | 709 | pr_info("sdcardfs: No longer mapping any files to gid %d\n", value->num); |
Daniel Rosenberg | ad90525 | 2017-01-25 13:48:45 -0800 | [diff] [blame] | 710 | kfree(value); |
| 711 | } |
| 712 | |
| 713 | static struct configfs_group_operations extensions_group_ops = { |
| 714 | .make_group = extensions_make_group, |
| 715 | .drop_item = extensions_drop_group, |
| 716 | }; |
| 717 | |
| 718 | static struct config_item_type extensions_type = { |
| 719 | .ct_group_ops = &extensions_group_ops, |
| 720 | .ct_owner = THIS_MODULE, |
| 721 | }; |
| 722 | |
| 723 | struct config_group extension_group = { |
| 724 | .cg_item = { |
| 725 | .ci_namebuf = "extensions", |
| 726 | .ci_type = &extensions_type, |
| 727 | }, |
| 728 | }; |
| 729 | |
Daniel Rosenberg | f48ace1 | 2017-01-21 00:35:26 -0800 | [diff] [blame] | 730 | static struct config_item *packages_make_item(struct config_group *group, const char *name) |
Daniel Rosenberg | 497ac90 | 2016-02-03 21:08:21 -0800 | [diff] [blame] | 731 | { |
Daniel Rosenberg | f48ace1 | 2017-01-21 00:35:26 -0800 | [diff] [blame] | 732 | struct package_details *package_details; |
Daniel Rosenberg | 52b7768 | 2017-01-27 19:35:08 -0800 | [diff] [blame] | 733 | const char *tmp; |
Daniel Rosenberg | 497ac90 | 2016-02-03 21:08:21 -0800 | [diff] [blame] | 734 | |
Daniel Rosenberg | f48ace1 | 2017-01-21 00:35:26 -0800 | [diff] [blame] | 735 | package_details = kzalloc(sizeof(struct package_details), GFP_KERNEL); |
| 736 | if (!package_details) |
Daniel Rosenberg | 497ac90 | 2016-02-03 21:08:21 -0800 | [diff] [blame] | 737 | return ERR_PTR(-ENOMEM); |
Daniel Rosenberg | 52b7768 | 2017-01-27 19:35:08 -0800 | [diff] [blame] | 738 | tmp = kstrdup(name, GFP_KERNEL); |
| 739 | if (!tmp) { |
Daniel Rosenberg | f48ace1 | 2017-01-21 00:35:26 -0800 | [diff] [blame] | 740 | kfree(package_details); |
| 741 | return ERR_PTR(-ENOMEM); |
| 742 | } |
Daniel Rosenberg | 52b7768 | 2017-01-27 19:35:08 -0800 | [diff] [blame] | 743 | qstr_init(&package_details->name, tmp); |
Daniel Rosenberg | f48ace1 | 2017-01-21 00:35:26 -0800 | [diff] [blame] | 744 | config_item_init_type_name(&package_details->item, name, |
Daniel Rosenberg | d8caaf9 | 2017-01-22 15:32:49 -0800 | [diff] [blame] | 745 | &package_appid_type); |
Daniel Rosenberg | 497ac90 | 2016-02-03 21:08:21 -0800 | [diff] [blame] | 746 | |
Daniel Rosenberg | f48ace1 | 2017-01-21 00:35:26 -0800 | [diff] [blame] | 747 | return &package_details->item; |
Daniel Rosenberg | 497ac90 | 2016-02-03 21:08:21 -0800 | [diff] [blame] | 748 | } |
| 749 | |
Daniel Rosenberg | f48ace1 | 2017-01-21 00:35:26 -0800 | [diff] [blame] | 750 | static ssize_t packages_list_show(struct config_item *item, char *page) |
Daniel Rosenberg | 497ac90 | 2016-02-03 21:08:21 -0800 | [diff] [blame] | 751 | { |
Daniel Rosenberg | d8caaf9 | 2017-01-22 15:32:49 -0800 | [diff] [blame] | 752 | struct hashtable_entry *hash_cur_app; |
| 753 | struct hashtable_entry *hash_cur_user; |
Daniel Rosenberg | 497ac90 | 2016-02-03 21:08:21 -0800 | [diff] [blame] | 754 | int i; |
Daniel Rosenberg | 0de3b4c | 2016-07-08 14:15:14 -0700 | [diff] [blame] | 755 | int count = 0, written = 0; |
Daniel Rosenberg | fbd34b6 | 2016-05-10 13:42:43 -0700 | [diff] [blame] | 756 | const char errormsg[] = "<truncated>\n"; |
Daniel Rosenberg | d8caaf9 | 2017-01-22 15:32:49 -0800 | [diff] [blame] | 757 | unsigned int hash; |
Daniel Rosenberg | 497ac90 | 2016-02-03 21:08:21 -0800 | [diff] [blame] | 758 | |
Daniel Rosenberg | fbd34b6 | 2016-05-10 13:42:43 -0700 | [diff] [blame] | 759 | rcu_read_lock(); |
Daniel Rosenberg | d8caaf9 | 2017-01-22 15:32:49 -0800 | [diff] [blame] | 760 | hash_for_each_rcu(package_to_appid, i, hash_cur_app, hlist) { |
Daniel Rosenberg | fbd34b6 | 2016-05-10 13:42:43 -0700 | [diff] [blame] | 761 | written = scnprintf(page + count, PAGE_SIZE - sizeof(errormsg) - count, "%s %d\n", |
Daniel Rosenberg | 52b7768 | 2017-01-27 19:35:08 -0800 | [diff] [blame] | 762 | hash_cur_app->key.name, atomic_read(&hash_cur_app->value)); |
| 763 | hash = hash_cur_app->key.hash; |
Daniel Rosenberg | d8caaf9 | 2017-01-22 15:32:49 -0800 | [diff] [blame] | 764 | hash_for_each_possible_rcu(package_to_userid, hash_cur_user, hlist, hash) { |
Daniel Rosenberg | 5004c5f | 2017-01-31 20:07:51 -0800 | [diff] [blame] | 765 | if (qstr_case_eq(&hash_cur_app->key, &hash_cur_user->key)) { |
Daniel Rosenberg | d8caaf9 | 2017-01-22 15:32:49 -0800 | [diff] [blame] | 766 | written += scnprintf(page + count + written - 1, |
| 767 | PAGE_SIZE - sizeof(errormsg) - count - written + 1, |
Daniel Rosenberg | 52b7768 | 2017-01-27 19:35:08 -0800 | [diff] [blame] | 768 | " %d\n", atomic_read(&hash_cur_user->value)) - 1; |
Daniel Rosenberg | d8caaf9 | 2017-01-22 15:32:49 -0800 | [diff] [blame] | 769 | } |
| 770 | } |
| 771 | if (count + written == PAGE_SIZE - sizeof(errormsg) - 1) { |
Daniel Rosenberg | 0de3b4c | 2016-07-08 14:15:14 -0700 | [diff] [blame] | 772 | count += scnprintf(page + count, PAGE_SIZE - count, errormsg); |
| 773 | break; |
| 774 | } |
| 775 | count += written; |
| 776 | } |
Daniel Rosenberg | fbd34b6 | 2016-05-10 13:42:43 -0700 | [diff] [blame] | 777 | rcu_read_unlock(); |
Daniel Rosenberg | 497ac90 | 2016-02-03 21:08:21 -0800 | [diff] [blame] | 778 | |
| 779 | return count; |
| 780 | } |
| 781 | |
Daniel Rosenberg | d8caaf9 | 2017-01-22 15:32:49 -0800 | [diff] [blame] | 782 | static ssize_t packages_remove_userid_store(struct config_item *item, |
| 783 | const char *page, size_t count) |
| 784 | { |
| 785 | unsigned int tmp; |
| 786 | int ret; |
| 787 | |
| 788 | ret = kstrtouint(page, 10, &tmp); |
| 789 | if (ret) |
| 790 | return ret; |
| 791 | remove_userid_all_entry(tmp); |
| 792 | return count; |
| 793 | } |
| 794 | |
Daniel Rosenberg | f48ace1 | 2017-01-21 00:35:26 -0800 | [diff] [blame] | 795 | static struct configfs_attribute packages_attr_packages_gid_list = { |
| 796 | .ca_name = "packages_gid.list", |
| 797 | .ca_mode = S_IRUGO, |
| 798 | .ca_owner = THIS_MODULE, |
| 799 | .show = packages_list_show, |
Daniel Rosenberg | 497ac90 | 2016-02-03 21:08:21 -0800 | [diff] [blame] | 800 | }; |
| 801 | |
Daniel Rosenberg | d8caaf9 | 2017-01-22 15:32:49 -0800 | [diff] [blame] | 802 | SDCARDFS_CONFIGFS_ATTR_WO(packages_, remove_userid); |
| 803 | |
Daniel Rosenberg | f48ace1 | 2017-01-21 00:35:26 -0800 | [diff] [blame] | 804 | static struct configfs_attribute *packages_attrs[] = { |
| 805 | &packages_attr_packages_gid_list, |
Daniel Rosenberg | d8caaf9 | 2017-01-22 15:32:49 -0800 | [diff] [blame] | 806 | &packages_attr_remove_userid, |
Daniel Rosenberg | 497ac90 | 2016-02-03 21:08:21 -0800 | [diff] [blame] | 807 | NULL, |
| 808 | }; |
| 809 | |
Daniel Rosenberg | 497ac90 | 2016-02-03 21:08:21 -0800 | [diff] [blame] | 810 | /* |
| 811 | * Note that, since no extra work is required on ->drop_item(), |
| 812 | * no ->drop_item() is provided. |
| 813 | */ |
Daniel Rosenberg | f48ace1 | 2017-01-21 00:35:26 -0800 | [diff] [blame] | 814 | static struct configfs_group_operations packages_group_ops = { |
| 815 | .make_item = packages_make_item, |
Daniel Rosenberg | 497ac90 | 2016-02-03 21:08:21 -0800 | [diff] [blame] | 816 | }; |
| 817 | |
Daniel Rosenberg | f48ace1 | 2017-01-21 00:35:26 -0800 | [diff] [blame] | 818 | static struct config_item_type packages_type = { |
| 819 | .ct_group_ops = &packages_group_ops, |
| 820 | .ct_attrs = packages_attrs, |
Daniel Rosenberg | 497ac90 | 2016-02-03 21:08:21 -0800 | [diff] [blame] | 821 | .ct_owner = THIS_MODULE, |
| 822 | }; |
| 823 | |
Daniel Rosenberg | ad90525 | 2017-01-25 13:48:45 -0800 | [diff] [blame] | 824 | struct config_group *sd_default_groups[] = { |
| 825 | &extension_group, |
| 826 | NULL, |
| 827 | }; |
| 828 | |
Daniel Rosenberg | f48ace1 | 2017-01-21 00:35:26 -0800 | [diff] [blame] | 829 | static struct configfs_subsystem sdcardfs_packages = { |
Daniel Rosenberg | 497ac90 | 2016-02-03 21:08:21 -0800 | [diff] [blame] | 830 | .su_group = { |
| 831 | .cg_item = { |
| 832 | .ci_namebuf = "sdcardfs", |
Daniel Rosenberg | f48ace1 | 2017-01-21 00:35:26 -0800 | [diff] [blame] | 833 | .ci_type = &packages_type, |
Daniel Rosenberg | 497ac90 | 2016-02-03 21:08:21 -0800 | [diff] [blame] | 834 | }, |
| 835 | }, |
| 836 | }; |
| 837 | |
Daniel Rosenberg | cfdb665 | 2016-03-28 16:00:34 -0700 | [diff] [blame] | 838 | static int configfs_sdcardfs_init(void) |
Daniel Rosenberg | 497ac90 | 2016-02-03 21:08:21 -0800 | [diff] [blame] | 839 | { |
Daniel Rosenberg | ad90525 | 2017-01-25 13:48:45 -0800 | [diff] [blame] | 840 | int ret, i; |
Daniel Rosenberg | f48ace1 | 2017-01-21 00:35:26 -0800 | [diff] [blame] | 841 | struct configfs_subsystem *subsys = &sdcardfs_packages; |
Daniel Rosenberg | 497ac90 | 2016-02-03 21:08:21 -0800 | [diff] [blame] | 842 | |
| 843 | config_group_init(&subsys->su_group); |
Daniel Rosenberg | ad90525 | 2017-01-25 13:48:45 -0800 | [diff] [blame] | 844 | for (i = 0; sd_default_groups[i]; i++) { |
| 845 | config_group_init(sd_default_groups[i]); |
| 846 | configfs_add_default_group(sd_default_groups[i], &subsys->su_group); |
| 847 | } |
Daniel Rosenberg | 497ac90 | 2016-02-03 21:08:21 -0800 | [diff] [blame] | 848 | mutex_init(&subsys->su_mutex); |
| 849 | ret = configfs_register_subsystem(subsys); |
| 850 | if (ret) { |
Daniel Rosenberg | 77ecf21 | 2017-03-16 17:46:13 -0700 | [diff] [blame] | 851 | pr_err("Error %d while registering subsystem %s\n", |
Daniel Rosenberg | 497ac90 | 2016-02-03 21:08:21 -0800 | [diff] [blame] | 852 | ret, |
| 853 | subsys->su_group.cg_item.ci_namebuf); |
| 854 | } |
| 855 | return ret; |
| 856 | } |
| 857 | |
Daniel Rosenberg | cfdb665 | 2016-03-28 16:00:34 -0700 | [diff] [blame] | 858 | static void configfs_sdcardfs_exit(void) |
Daniel Rosenberg | 497ac90 | 2016-02-03 21:08:21 -0800 | [diff] [blame] | 859 | { |
Daniel Rosenberg | f48ace1 | 2017-01-21 00:35:26 -0800 | [diff] [blame] | 860 | configfs_unregister_subsystem(&sdcardfs_packages); |
Daniel Rosenberg | 497ac90 | 2016-02-03 21:08:21 -0800 | [diff] [blame] | 861 | } |
| 862 | |
Daniel Campello | 35c9e24 | 2015-07-20 16:23:50 -0700 | [diff] [blame] | 863 | int packagelist_init(void) |
| 864 | { |
| 865 | hashtable_entry_cachep = |
| 866 | kmem_cache_create("packagelist_hashtable_entry", |
| 867 | sizeof(struct hashtable_entry), 0, 0, NULL); |
| 868 | if (!hashtable_entry_cachep) { |
Daniel Rosenberg | 77ecf21 | 2017-03-16 17:46:13 -0700 | [diff] [blame] | 869 | pr_err("sdcardfs: failed creating pkgl_hashtable entry slab cache\n"); |
Daniel Campello | 35c9e24 | 2015-07-20 16:23:50 -0700 | [diff] [blame] | 870 | return -ENOMEM; |
| 871 | } |
| 872 | |
Daniel Rosenberg | 497ac90 | 2016-02-03 21:08:21 -0800 | [diff] [blame] | 873 | configfs_sdcardfs_init(); |
Daniel Rosenberg | 5e024f6 | 2017-03-16 17:42:58 -0700 | [diff] [blame] | 874 | return 0; |
Daniel Campello | 35c9e24 | 2015-07-20 16:23:50 -0700 | [diff] [blame] | 875 | } |
| 876 | |
| 877 | void packagelist_exit(void) |
| 878 | { |
Daniel Rosenberg | 497ac90 | 2016-02-03 21:08:21 -0800 | [diff] [blame] | 879 | configfs_sdcardfs_exit(); |
Daniel Rosenberg | fbd34b6 | 2016-05-10 13:42:43 -0700 | [diff] [blame] | 880 | packagelist_destroy(); |
Daniel Rosenberg | b6704a8 | 2017-03-21 16:29:13 -0700 | [diff] [blame] | 881 | kmem_cache_destroy(hashtable_entry_cachep); |
Daniel Campello | 35c9e24 | 2015-07-20 16:23:50 -0700 | [diff] [blame] | 882 | } |