fs/sdcardfs/derived_perm.c

   1 /*
   2  * fs/sdcardfs/derived_perm.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"
  22
  23 /* copy derived state from parent inode */
  24 static void inherit_derived_state(struct inode *parent, struct inode *child)
  25 {
  26         struct sdcardfs_inode_info *pi = SDCARDFS_I(parent);
  27         struct sdcardfs_inode_info *ci = SDCARDFS_I(child);
  28
  29         ci->data->perm = PERM_INHERIT;
  30         ci->data->userid = pi->data->userid;
  31         ci->data->d_uid = pi->data->d_uid;
  32         ci->data->under_android = pi->data->under_android;
  33         ci->data->under_cache = pi->data->under_cache;
  34         ci->data->under_obb = pi->data->under_obb;
  35 }
  36
  37 /* helper function for derived state */
  38 void setup_derived_state(struct inode *inode, perm_t perm, userid_t userid,
  39                                         uid_t uid)
  40 {
  41         struct sdcardfs_inode_info *info = SDCARDFS_I(inode);
  42
  43         info->data->perm = perm;
  44         info->data->userid = userid;
  45         info->data->d_uid = uid;
  46         info->data->under_android = false;
  47         info->data->under_cache = false;
  48         info->data->under_obb = false;
  49 }
  50
  51 /* While renaming, there is a point where we want the path from dentry,
  52  * but the name from newdentry
  53  */
  54 void get_derived_permission_new(struct dentry *parent, struct dentry *dentry,
  55                                 const struct qstr *name)
  56 {
  57         struct sdcardfs_inode_info *info = SDCARDFS_I(dentry->d_inode);
  58         struct sdcardfs_inode_info *parent_info = SDCARDFS_I(parent->d_inode);
  59         struct sdcardfs_inode_data *parent_data = parent_info->data;
  60         appid_t appid;
  61         unsigned long user_num;
  62         int err;
  63         struct qstr q_Android = QSTR_LITERAL("Android");
  64         struct qstr q_data = QSTR_LITERAL("data");
  65         struct qstr q_sandbox = QSTR_LITERAL("sandbox");
  66         struct qstr q_obb = QSTR_LITERAL("obb");
  67         struct qstr q_media = QSTR_LITERAL("media");
  68         struct qstr q_cache = QSTR_LITERAL("cache");
  69
  70         /* By default, each inode inherits from its parent.
  71          * the properties are maintained on its private fields
  72          * because the inode attributes will be modified with that of
  73          * its lower inode.
  74          * These values are used by our custom permission call instead
  75          * of using the inode permissions.
  76          */
  77
  78         inherit_derived_state(parent->d_inode, dentry->d_inode);
  79
  80         /* Files don't get special labels */
  81         if (!S_ISDIR(dentry->d_inode->i_mode)) {
  82                 set_top(info, parent_info);
  83                 return;
  84         }
  85         /* Derive custom permissions based on parent and current node */
  86         switch (parent_data->perm) {
  87         case PERM_INHERIT:
  88         case PERM_ANDROID_PACKAGE_CACHE:
  89                 set_top(info, parent_info);
  90                 break;
  91         case PERM_PRE_ROOT:
  92                 /* Legacy internal layout places users at top level */
  93                 info->data->perm = PERM_ROOT;
  94                 err = kstrtoul(name->name, 10, &user_num);
  95                 if (err)
  96                         info->data->userid = 0;
  97                 else
  98                         info->data->userid = user_num;
  99                 break;
 100         case PERM_ROOT:
 101                 /* Assume masked off by default. */
 102                 if (qstr_case_eq(name, &q_Android)) {
 103                         /* App-specific directories inside; let anyone traverse */
 104                         info->data->perm = PERM_ANDROID;
 105                         info->data->under_android = true;
 106                 } else {
 107                         set_top(info, parent_info);
 108                 }
 109                 break;
 110         case PERM_ANDROID:
 111                 if (qstr_case_eq(name, &q_data)) {
 112                         /* App-specific directories inside; let anyone traverse */
 113                         info->data->perm = PERM_ANDROID_DATA;
 114                 } else if (qstr_case_eq(name, &q_sandbox)) {
 115                         /* App-specific directories inside; let anyone traverse */
 116                         info->data->perm = PERM_ANDROID_DATA;
 117                 } else if (qstr_case_eq(name, &q_obb)) {
 118                         /* App-specific directories inside; let anyone traverse */
 119                         info->data->perm = PERM_ANDROID_OBB;
 120                         info->data->under_obb = true;
 121                         /* Single OBB directory is always shared */
 122                 } else if (qstr_case_eq(name, &q_media)) {
 123                         /* App-specific directories inside; let anyone traverse */
 124                         info->data->perm = PERM_ANDROID_MEDIA;
 125                 } else {
 126                         set_top(info, parent_info);
 127                 }
 128                 break;
 129         case PERM_ANDROID_OBB:
 130         case PERM_ANDROID_DATA:
 131         case PERM_ANDROID_MEDIA:
 132                 info->data->perm = PERM_ANDROID_PACKAGE;
 133                 appid = get_appid(name->name);
 134                 if (appid != 0 && !is_excluded(name->name, parent_data->userid))
 135                         info->data->d_uid =
 136                                 multiuser_get_uid(parent_data->userid, appid);
 137                 break;
 138         case PERM_ANDROID_PACKAGE:
 139                 if (qstr_case_eq(name, &q_cache)) {
 140                         info->data->perm = PERM_ANDROID_PACKAGE_CACHE;
 141                         info->data->under_cache = true;
 142                 }
 143                 set_top(info, parent_info);
 144                 break;
 145         }
 146 }
 147
 148 void get_derived_permission(struct dentry *parent, struct dentry *dentry)
 149 {
 150         get_derived_permission_new(parent, dentry, &dentry->d_name);
 151 }
 152
 153 static appid_t get_type(const char *name)
 154 {
 155         const char *ext = strrchr(name, '.');
 156         appid_t id;
 157
 158         if (ext && ext[0]) {
 159                 ext = &ext[1];
 160                 id = get_ext_gid(ext);
 161                 return id?:AID_MEDIA_RW;
 162         }
 163         return AID_MEDIA_RW;
 164 }
 165
 166 void fixup_lower_ownership(struct dentry *dentry, const char *name)
 167 {
 168         struct path path;
 169         struct inode *inode;
 170         int error;
 171         struct sdcardfs_inode_info *info;
 172         struct sdcardfs_inode_data *info_d;
 173         struct sdcardfs_inode_data *info_top;
 174         perm_t perm;
 175         struct sdcardfs_sb_info *sbi = SDCARDFS_SB(dentry->d_sb);
 176         uid_t uid = sbi->options.fs_low_uid;
 177         gid_t gid = sbi->options.fs_low_gid;
 178         struct iattr newattrs;
 179
 180         if (!sbi->options.gid_derivation)
 181                 return;
 182
 183         info = SDCARDFS_I(dentry->d_inode);
 184         info_d = info->data;
 185         perm = info_d->perm;
 186         if (info_d->under_obb) {
 187                 perm = PERM_ANDROID_OBB;
 188         } else if (info_d->under_cache) {
 189                 perm = PERM_ANDROID_PACKAGE_CACHE;
 190         } else if (perm == PERM_INHERIT) {
 191                 info_top = top_data_get(info);
 192                 perm = info_top->perm;
 193                 data_put(info_top);
 194         }
 195
 196         switch (perm) {
 197         case PERM_ROOT:
 198         case PERM_ANDROID:
 199         case PERM_ANDROID_DATA:
 200         case PERM_ANDROID_MEDIA:
 201         case PERM_ANDROID_PACKAGE:
 202         case PERM_ANDROID_PACKAGE_CACHE:
 203                 uid = multiuser_get_uid(info_d->userid, uid);
 204                 break;
 205         case PERM_ANDROID_OBB:
 206                 uid = AID_MEDIA_OBB;
 207                 break;
 208         case PERM_PRE_ROOT:
 209         default:
 210                 break;
 211         }
 212         switch (perm) {
 213         case PERM_ROOT:
 214         case PERM_ANDROID:
 215         case PERM_ANDROID_DATA:
 216         case PERM_ANDROID_MEDIA:
 217                 if (S_ISDIR(dentry->d_inode->i_mode))
 218                         gid = multiuser_get_uid(info_d->userid, AID_MEDIA_RW);
 219                 else
 220                         gid = multiuser_get_uid(info_d->userid, get_type(name));
 221                 break;
 222         case PERM_ANDROID_OBB:
 223                 gid = AID_MEDIA_OBB;
 224                 break;
 225         case PERM_ANDROID_PACKAGE:
 226                 if (uid_is_app(info_d->d_uid))
 227                         gid = multiuser_get_ext_gid(info_d->d_uid);
 228                 else
 229                         gid = multiuser_get_uid(info_d->userid, AID_MEDIA_RW);
 230                 break;
 231         case PERM_ANDROID_PACKAGE_CACHE:
 232                 if (uid_is_app(info_d->d_uid))
 233                         gid = multiuser_get_ext_cache_gid(info_d->d_uid);
 234                 else
 235                         gid = multiuser_get_uid(info_d->userid, AID_MEDIA_RW);
 236                 break;
 237         case PERM_PRE_ROOT:
 238         default:
 239                 break;
 240         }
 241
 242         sdcardfs_get_lower_path(dentry, &path);
 243         inode = path.dentry->d_inode;
 244         if (path.dentry->d_inode->i_gid != gid || path.dentry->d_inode->i_uid != uid) {
 245                 newattrs.ia_valid = ATTR_GID | ATTR_UID | ATTR_FORCE;
 246                 newattrs.ia_uid = make_kuid(current_user_ns(), uid);
 247                 newattrs.ia_gid = make_kgid(current_user_ns(), gid);
 248                 if (!S_ISDIR(inode->i_mode))
 249                         newattrs.ia_valid |=
 250                                 ATTR_KILL_SUID | ATTR_KILL_SGID | ATTR_KILL_PRIV;
 251                 mutex_lock(&inode->i_mutex);
 252                 error = security_path_chown(&path, newattrs.ia_uid, newattrs.ia_gid);
 253                 if (!error)
 254                         error = notify_change2(path.mnt, path.dentry, &newattrs);
 255                 mutex_unlock(&inode->i_mutex);
 256                 if (error)
 257                         pr_debug("sdcardfs: Failed to touch up lower fs gid/uid for %s\n", name);
 258         }
 259         sdcardfs_put_lower_path(dentry, &path);
 260 }
 261
 262 static int descendant_may_need_fixup(struct sdcardfs_inode_data *data,
 263                 struct limit_search *limit)
 264 {
 265         if (data->perm == PERM_ROOT)
 266                 return (limit->flags & BY_USERID) ?
 267                                 data->userid == limit->userid : 1;
 268         if (data->perm == PERM_PRE_ROOT || data->perm == PERM_ANDROID)
 269                 return 1;
 270         return 0;
 271 }
 272
 273 static int needs_fixup(perm_t perm)
 274 {
 275         if (perm == PERM_ANDROID_DATA || perm == PERM_ANDROID_OBB
 276                         || perm == PERM_ANDROID_MEDIA)
 277                 return 1;
 278         return 0;
 279 }
 280
 281 static void __fixup_perms_recursive(struct dentry *dentry, struct limit_search *limit, int depth)
 282 {
 283         struct dentry *child;
 284         struct sdcardfs_inode_info *info;
 285
 286         /*
 287          * All paths will terminate their recursion on hitting PERM_ANDROID_OBB,
 288          * PERM_ANDROID_MEDIA, or PERM_ANDROID_DATA. This happens at a depth of
 289          * at most 3.
 290          */
 291         WARN(depth > 3, "%s: Max expected depth exceeded!\n", __func__);
 292         spin_lock_nested(&dentry->d_lock, depth);
 293         if (!dentry->d_inode) {
 294                 spin_unlock(&dentry->d_lock);
 295                 return;
 296         }
 297         info = SDCARDFS_I(dentry->d_inode);
 298
 299         if (needs_fixup(info->data->perm)) {
 300                 list_for_each_entry(child, &dentry->d_subdirs, d_child) {
 301                         spin_lock_nested(&child->d_lock, depth + 1);
 302                         if (!(limit->flags & BY_NAME) || qstr_case_eq(&child->d_name, &limit->name)) {
 303                                 if (child->d_inode) {
 304                                         get_derived_permission(dentry, child);
 305                                         fixup_tmp_permissions(child->d_inode);
 306                                         spin_unlock(&child->d_lock);
 307                                         break;
 308                                 }
 309                         }
 310                         spin_unlock(&child->d_lock);
 311                 }
 312         } else if (descendant_may_need_fixup(info->data, limit)) {
 313                 list_for_each_entry(child, &dentry->d_subdirs, d_child) {
 314                         __fixup_perms_recursive(child, limit, depth + 1);
 315                 }
 316         }
 317         spin_unlock(&dentry->d_lock);
 318 }
 319
 320 void fixup_perms_recursive(struct dentry *dentry, struct limit_search *limit)
 321 {
 322         __fixup_perms_recursive(dentry, limit, 0);
 323 }
 324
 325 /* main function for updating derived permission */
 326 inline void update_derived_permission_lock(struct dentry *dentry)
 327 {
 328         struct dentry *parent;
 329
 330         if (!dentry || !dentry->d_inode) {
 331                 pr_err("sdcardfs: %s: invalid dentry\n", __func__);
 332                 return;
 333         }
 334         /* FIXME:
 335          * 1. need to check whether the dentry is updated or not
 336          * 2. remove the root dentry update
 337          */
 338         if (!IS_ROOT(dentry)) {
 339                 parent = dget_parent(dentry);
 340                 if (parent) {
 341                         get_derived_permission(parent, dentry);
 342                         dput(parent);
 343                 }
 344         }
 345         fixup_tmp_permissions(dentry->d_inode);
 346 }
 347
 348 int need_graft_path(struct dentry *dentry)
 349 {
 350         int ret = 0;
 351         struct dentry *parent = dget_parent(dentry);
 352         struct sdcardfs_inode_info *parent_info = SDCARDFS_I(parent->d_inode);
 353         struct sdcardfs_sb_info *sbi = SDCARDFS_SB(dentry->d_sb);
 354         struct qstr obb = QSTR_LITERAL("obb");
 355
 356         if (parent_info->data->perm == PERM_ANDROID &&
 357                         qstr_case_eq(&dentry->d_name, &obb)) {
 358
 359                 /* /Android/obb is the base obbpath of DERIVED_UNIFIED */
 360                 if (!(sbi->options.multiuser == false
 361                                 && parent_info->data->userid == 0)) {
 362                         ret = 1;
 363                 }
 364         }
 365         dput(parent);
 366         return ret;
 367 }
 368
 369 int is_obbpath_invalid(struct dentry *dent)
 370 {
 371         int ret = 0;
 372         struct sdcardfs_dentry_info *di = SDCARDFS_D(dent);
 373         struct sdcardfs_sb_info *sbi = SDCARDFS_SB(dent->d_sb);
 374         char *path_buf, *obbpath_s;
 375         int need_put = 0;
 376         struct path lower_path;
 377
 378         /* check the base obbpath has been changed.
 379          * this routine can check an uninitialized obb dentry as well.
 380          * regarding the uninitialized obb, refer to the sdcardfs_mkdir()
 381          */
 382         spin_lock(&di->lock);
 383         if (di->orig_path.dentry) {
 384                 if (!di->lower_path.dentry) {
 385                         ret = 1;
 386                 } else {
 387                         path_get(&di->lower_path);
 388
 389                         path_buf = kmalloc(PATH_MAX, GFP_ATOMIC);
 390                         if (!path_buf) {
 391                                 ret = 1;
 392                                 pr_err("sdcardfs: fail to allocate path_buf in %s.\n", __func__);
 393                         } else {
 394                                 obbpath_s = d_path(&di->lower_path, path_buf, PATH_MAX);
 395                                 if (d_unhashed(di->lower_path.dentry) ||
 396                                         !str_case_eq(sbi->obbpath_s, obbpath_s)) {
 397                                         ret = 1;
 398                                 }
 399                                 kfree(path_buf);
 400                         }
 401
 402                         pathcpy(&lower_path, &di->lower_path);
 403                         need_put = 1;
 404                 }
 405         }
 406         spin_unlock(&di->lock);
 407         if (need_put)
 408                 path_put(&lower_path);
 409         return ret;
 410 }
 411
 412 int is_base_obbpath(struct dentry *dentry)
 413 {
 414         int ret = 0;
 415         struct dentry *parent = dget_parent(dentry);
 416         struct sdcardfs_inode_info *parent_info = SDCARDFS_I(parent->d_inode);
 417         struct sdcardfs_sb_info *sbi = SDCARDFS_SB(dentry->d_sb);
 418         struct qstr q_obb = QSTR_LITERAL("obb");
 419
 420         spin_lock(&SDCARDFS_D(dentry)->lock);
 421         if (sbi->options.multiuser) {
 422                 if (parent_info->data->perm == PERM_PRE_ROOT &&
 423                                 qstr_case_eq(&dentry->d_name, &q_obb)) {
 424                         ret = 1;
 425                 }
 426         } else  if (parent_info->data->perm == PERM_ANDROID &&
 427                         qstr_case_eq(&dentry->d_name, &q_obb)) {
 428                 ret = 1;
 429         }
 430         spin_unlock(&SDCARDFS_D(dentry)->lock);
 431         return ret;
 432 }
 433
 434 /* The lower_path will be stored to the dentry's orig_path
 435  * and the base obbpath will be copyed to the lower_path variable.
 436  * if an error returned, there's no change in the lower_path
 437  * returns: -ERRNO if error (0: no error)
 438  */
 439 int setup_obb_dentry(struct dentry *dentry, struct path *lower_path)
 440 {
 441         int err = 0;
 442         struct sdcardfs_sb_info *sbi = SDCARDFS_SB(dentry->d_sb);
 443         struct path obbpath;
 444
 445         /* A local obb dentry must have its own orig_path to support rmdir
 446          * and mkdir of itself. Usually, we expect that the sbi->obbpath
 447          * is avaiable on this stage.
 448          */
 449         sdcardfs_set_orig_path(dentry, lower_path);
 450
 451         err = kern_path(sbi->obbpath_s,
 452                         LOOKUP_FOLLOW | LOOKUP_DIRECTORY, &obbpath);
 453
 454         if (!err) {
 455                 /* the obbpath base has been found */
 456                 pathcpy(lower_path, &obbpath);
 457         } else {
 458                 /* if the sbi->obbpath is not available, we can optionally
 459                  * setup the lower_path with its orig_path.
 460                  * but, the current implementation just returns an error
 461                  * because the sdcard daemon also regards this case as
 462                  * a lookup fail.
 463                  */
 464                 pr_info("sdcardfs: the sbi->obbpath is not available\n");
 465         }
 466         return err;
 467 }
 468
 469