blob: 1b5029d819214cddd4affbb3b6d559a19d7ea7e8 [file] [log] [blame]
Daniel Campello35c9e242015-07-20 16:23:50 -07001/*
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 */
24static 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->perm = PERM_INHERIT;
30 ci->userid = pi->userid;
31 ci->d_uid = pi->d_uid;
Daniel Rosenberg497ac902016-02-03 21:08:21 -080032 ci->under_android = pi->under_android;
Daniel Rosenbergad905252017-01-25 13:48:45 -080033 ci->under_cache = pi->under_cache;
34 ci->under_obb = pi->under_obb;
Daniel Rosenberg5080d242016-05-18 16:57:10 -070035 set_top(ci, pi->top);
Daniel Campello35c9e242015-07-20 16:23:50 -070036}
37
38/* helper function for derived state */
Daniel Rosenberg5080d242016-05-18 16:57:10 -070039void setup_derived_state(struct inode *inode, perm_t perm, userid_t userid,
40 uid_t uid, bool under_android, struct inode *top)
Daniel Campello35c9e242015-07-20 16:23:50 -070041{
42 struct sdcardfs_inode_info *info = SDCARDFS_I(inode);
43
44 info->perm = perm;
45 info->userid = userid;
46 info->d_uid = uid;
Daniel Rosenberg497ac902016-02-03 21:08:21 -080047 info->under_android = under_android;
Daniel Rosenbergad905252017-01-25 13:48:45 -080048 info->under_cache = false;
49 info->under_obb = false;
Daniel Rosenberg5080d242016-05-18 16:57:10 -070050 set_top(info, top);
Daniel Campello35c9e242015-07-20 16:23:50 -070051}
52
Daniel Rosenberg497ac902016-02-03 21:08:21 -080053/* While renaming, there is a point where we want the path from dentry, but the name from newdentry */
Daniel Rosenberg5004c5f2017-01-31 20:07:51 -080054void get_derived_permission_new(struct dentry *parent, struct dentry *dentry, const struct qstr *name)
Daniel Campello35c9e242015-07-20 16:23:50 -070055{
Daniel Rosenberg63d20762016-12-01 14:36:29 -080056 struct sdcardfs_inode_info *info = SDCARDFS_I(d_inode(dentry));
57 struct sdcardfs_inode_info *parent_info= SDCARDFS_I(d_inode(parent));
Daniel Campello35c9e242015-07-20 16:23:50 -070058 appid_t appid;
Daniel Rosenberg5004c5f2017-01-31 20:07:51 -080059 struct qstr q_Android = QSTR_LITERAL("Android");
60 struct qstr q_data = QSTR_LITERAL("data");
61 struct qstr q_obb = QSTR_LITERAL("obb");
62 struct qstr q_media = QSTR_LITERAL("media");
63 struct qstr q_cache = QSTR_LITERAL("cache");
Daniel Campello35c9e242015-07-20 16:23:50 -070064
65 /* By default, each inode inherits from its parent.
66 * the properties are maintained on its private fields
67 * because the inode attributes will be modified with that of
68 * its lower inode.
Daniel Rosenbergad905252017-01-25 13:48:45 -080069 * These values are used by our custom permission call instead
70 * of using the inode permissions.
Daniel Campello35c9e242015-07-20 16:23:50 -070071 */
72
Daniel Rosenberg63d20762016-12-01 14:36:29 -080073 inherit_derived_state(d_inode(parent), d_inode(dentry));
Daniel Campello35c9e242015-07-20 16:23:50 -070074
Daniel Rosenbergad905252017-01-25 13:48:45 -080075 /* Files don't get special labels */
76 if (!S_ISDIR(d_inode(dentry)->i_mode))
77 return;
Daniel Campello35c9e242015-07-20 16:23:50 -070078 /* Derive custom permissions based on parent and current node */
79 switch (parent_info->perm) {
Daniel Rosenbergad905252017-01-25 13:48:45 -080080 case PERM_INHERIT:
81 case PERM_ANDROID_PACKAGE_CACHE:
82 /* Already inherited above */
83 break;
84 case PERM_PRE_ROOT:
85 /* Legacy internal layout places users at top level */
86 info->perm = PERM_ROOT;
Daniel Rosenberg5004c5f2017-01-31 20:07:51 -080087 info->userid = simple_strtoul(name->name, NULL, 10);
Daniel Rosenbergad905252017-01-25 13:48:45 -080088 set_top(info, &info->vfs_inode);
89 break;
90 case PERM_ROOT:
91 /* Assume masked off by default. */
Daniel Rosenberg5004c5f2017-01-31 20:07:51 -080092 if (qstr_case_eq(name, &q_Android)) {
Daniel Rosenbergad905252017-01-25 13:48:45 -080093 /* App-specific directories inside; let anyone traverse */
94 info->perm = PERM_ANDROID;
95 info->under_android = true;
Daniel Rosenberg5080d242016-05-18 16:57:10 -070096 set_top(info, &info->vfs_inode);
Daniel Rosenbergad905252017-01-25 13:48:45 -080097 }
98 break;
99 case PERM_ANDROID:
Daniel Rosenberg5004c5f2017-01-31 20:07:51 -0800100 if (qstr_case_eq(name, &q_data)) {
Daniel Rosenbergad905252017-01-25 13:48:45 -0800101 /* App-specific directories inside; let anyone traverse */
102 info->perm = PERM_ANDROID_DATA;
Daniel Rosenberg5080d242016-05-18 16:57:10 -0700103 set_top(info, &info->vfs_inode);
Daniel Rosenberg5004c5f2017-01-31 20:07:51 -0800104 } else if (qstr_case_eq(name, &q_obb)) {
Daniel Rosenbergad905252017-01-25 13:48:45 -0800105 /* App-specific directories inside; let anyone traverse */
106 info->perm = PERM_ANDROID_OBB;
107 info->under_obb = true;
108 set_top(info, &info->vfs_inode);
109 /* Single OBB directory is always shared */
Daniel Rosenberg5004c5f2017-01-31 20:07:51 -0800110 } else if (qstr_case_eq(name, &q_media)) {
Daniel Rosenbergad905252017-01-25 13:48:45 -0800111 /* App-specific directories inside; let anyone traverse */
112 info->perm = PERM_ANDROID_MEDIA;
113 set_top(info, &info->vfs_inode);
114 }
115 break;
116 case PERM_ANDROID_OBB:
117 case PERM_ANDROID_DATA:
118 case PERM_ANDROID_MEDIA:
119 info->perm = PERM_ANDROID_PACKAGE;
Daniel Rosenberg5004c5f2017-01-31 20:07:51 -0800120 appid = get_appid(name->name);
121 if (appid != 0 && !is_excluded(name->name, parent_info->userid)) {
Daniel Rosenbergad905252017-01-25 13:48:45 -0800122 info->d_uid = multiuser_get_uid(parent_info->userid, appid);
123 }
124 set_top(info, &info->vfs_inode);
125 break;
126 case PERM_ANDROID_PACKAGE:
Daniel Rosenberg5004c5f2017-01-31 20:07:51 -0800127 if (qstr_case_eq(name, &q_cache)) {
Daniel Rosenbergad905252017-01-25 13:48:45 -0800128 info->perm = PERM_ANDROID_PACKAGE_CACHE;
129 info->under_cache = true;
130 }
131 break;
Daniel Campello35c9e242015-07-20 16:23:50 -0700132 }
133}
134
Daniel Rosenberg497ac902016-02-03 21:08:21 -0800135void get_derived_permission(struct dentry *parent, struct dentry *dentry)
136{
Daniel Rosenberg5004c5f2017-01-31 20:07:51 -0800137 get_derived_permission_new(parent, dentry, &dentry->d_name);
Daniel Rosenbergad905252017-01-25 13:48:45 -0800138}
139
140static appid_t get_type(const char *name)
141{
142 const char *ext = strrchr(name, '.');
143 appid_t id;
144
145 if (ext && ext[0]) {
146 ext = &ext[1];
147 id = get_ext_gid(ext);
148 return id?:AID_MEDIA_RW;
149 }
150 return AID_MEDIA_RW;
151}
152
153void fixup_lower_ownership(struct dentry *dentry, const char *name)
154{
155 struct path path;
156 struct inode *inode;
157 struct inode *delegated_inode = NULL;
158 int error;
159 struct sdcardfs_inode_info *info;
160 struct sdcardfs_inode_info *info_top;
161 perm_t perm;
162 struct sdcardfs_sb_info *sbi = SDCARDFS_SB(dentry->d_sb);
163 uid_t uid = sbi->options.fs_low_uid;
164 gid_t gid = sbi->options.fs_low_gid;
165 struct iattr newattrs;
166
167 info = SDCARDFS_I(d_inode(dentry));
168 perm = info->perm;
169 if (info->under_obb) {
170 perm = PERM_ANDROID_OBB;
171 } else if (info->under_cache) {
172 perm = PERM_ANDROID_PACKAGE_CACHE;
173 } else if (perm == PERM_INHERIT) {
174 info_top = SDCARDFS_I(grab_top(info));
175 perm = info_top->perm;
176 release_top(info);
177 }
178
179 switch (perm) {
180 case PERM_ROOT:
181 case PERM_ANDROID:
182 case PERM_ANDROID_DATA:
183 case PERM_ANDROID_MEDIA:
184 case PERM_ANDROID_PACKAGE:
185 case PERM_ANDROID_PACKAGE_CACHE:
186 uid = multiuser_get_uid(info->userid, uid);
187 break;
188 case PERM_ANDROID_OBB:
189 uid = AID_MEDIA_OBB;
190 break;
191 case PERM_PRE_ROOT:
192 default:
193 break;
194 }
195 switch (perm) {
196 case PERM_ROOT:
197 case PERM_ANDROID:
198 case PERM_ANDROID_DATA:
199 case PERM_ANDROID_MEDIA:
200 if (S_ISDIR(d_inode(dentry)->i_mode))
201 gid = multiuser_get_uid(info->userid, AID_MEDIA_RW);
202 else
203 gid = multiuser_get_uid(info->userid, get_type(name));
204 break;
205 case PERM_ANDROID_OBB:
206 gid = AID_MEDIA_OBB;
207 break;
208 case PERM_ANDROID_PACKAGE:
209 if (info->d_uid != 0)
210 gid = multiuser_get_ext_gid(info->userid, info->d_uid);
211 else
212 gid = multiuser_get_uid(info->userid, uid);
213 break;
214 case PERM_ANDROID_PACKAGE_CACHE:
215 if (info->d_uid != 0)
216 gid = multiuser_get_cache_gid(info->userid, info->d_uid);
217 else
218 gid = multiuser_get_uid(info->userid, uid);
219 break;
220 case PERM_PRE_ROOT:
221 default:
222 break;
223 }
224
225 sdcardfs_get_lower_path(dentry, &path);
226 inode = d_inode(path.dentry);
227 if (d_inode(path.dentry)->i_gid.val != gid || d_inode(path.dentry)->i_uid.val != uid) {
228retry_deleg:
229 newattrs.ia_valid = ATTR_GID | ATTR_UID | ATTR_FORCE;
230 newattrs.ia_uid = make_kuid(current_user_ns(), uid);
231 newattrs.ia_gid = make_kgid(current_user_ns(), gid);
232 if (!S_ISDIR(inode->i_mode))
233 newattrs.ia_valid |=
234 ATTR_KILL_SUID | ATTR_KILL_SGID | ATTR_KILL_PRIV;
235 inode_lock(inode);
236 error = security_path_chown(&path, newattrs.ia_uid, newattrs.ia_gid);
237 if (!error)
238 error = notify_change2(path.mnt, path.dentry, &newattrs, &delegated_inode);
239 inode_unlock(inode);
240 if (delegated_inode) {
241 error = break_deleg_wait(&delegated_inode);
242 if (!error)
243 goto retry_deleg;
244 }
245 if (error)
246 pr_err("sdcardfs: Failed to touch up lower fs gid/uid.\n");
247 }
Daniel Rosenbergf61bc5a2017-02-16 17:55:22 -0800248 sdcardfs_put_lower_path(dentry, &path);
Daniel Rosenberg497ac902016-02-03 21:08:21 -0800249}
250
Daniel Rosenbergd8caaf92017-01-22 15:32:49 -0800251static int descendant_may_need_fixup(struct sdcardfs_inode_info *info, struct limit_search *limit)
252{
253 if (info->perm == PERM_ROOT)
254 return (limit->flags & BY_USERID)?info->userid == limit->userid:1;
255 if (info->perm == PERM_PRE_ROOT || info->perm == PERM_ANDROID)
Daniel Rosenberg5080d242016-05-18 16:57:10 -0700256 return 1;
257 return 0;
258}
259
260static int needs_fixup(perm_t perm) {
261 if (perm == PERM_ANDROID_DATA || perm == PERM_ANDROID_OBB
262 || perm == PERM_ANDROID_MEDIA)
263 return 1;
264 return 0;
265}
266
Daniel Rosenbergd8caaf92017-01-22 15:32:49 -0800267void fixup_perms_recursive(struct dentry *dentry, struct limit_search *limit)
268{
Daniel Rosenberg5080d242016-05-18 16:57:10 -0700269 struct dentry *child;
270 struct sdcardfs_inode_info *info;
271 if (!dget(dentry))
272 return;
Daniel Rosenberg63d20762016-12-01 14:36:29 -0800273 if (!d_inode(dentry)) {
Daniel Rosenberg5080d242016-05-18 16:57:10 -0700274 dput(dentry);
275 return;
276 }
277 info = SDCARDFS_I(d_inode(dentry));
278
279 if (needs_fixup(info->perm)) {
Daniel Rosenberg3adfc032016-12-27 12:36:29 -0800280 spin_lock(&dentry->d_lock);
281 list_for_each_entry(child, &dentry->d_subdirs, d_child) {
Daniel Rosenbergd8caaf92017-01-22 15:32:49 -0800282 dget(child);
283 if (!(limit->flags & BY_NAME) || !strncasecmp(child->d_name.name, limit->name, limit->length)) {
284 if (d_inode(child)) {
285 get_derived_permission(dentry, child);
286 fixup_tmp_permissions(d_inode(child));
287 dput(child);
288 break;
Daniel Rosenberg3adfc032016-12-27 12:36:29 -0800289 }
Daniel Rosenbergd8caaf92017-01-22 15:32:49 -0800290 }
291 dput(child);
Daniel Rosenberg5080d242016-05-18 16:57:10 -0700292 }
Daniel Rosenberg3adfc032016-12-27 12:36:29 -0800293 spin_unlock(&dentry->d_lock);
Daniel Rosenbergd8caaf92017-01-22 15:32:49 -0800294 } else if (descendant_may_need_fixup(info, limit)) {
Daniel Rosenberg3adfc032016-12-27 12:36:29 -0800295 spin_lock(&dentry->d_lock);
Daniel Rosenberg5080d242016-05-18 16:57:10 -0700296 list_for_each_entry(child, &dentry->d_subdirs, d_child) {
Daniel Rosenbergd8caaf92017-01-22 15:32:49 -0800297 fixup_perms_recursive(child, limit);
Daniel Rosenberg5080d242016-05-18 16:57:10 -0700298 }
Daniel Rosenberg3adfc032016-12-27 12:36:29 -0800299 spin_unlock(&dentry->d_lock);
Daniel Rosenberg5080d242016-05-18 16:57:10 -0700300 }
301 dput(dentry);
302}
303
Daniel Rosenbergad905252017-01-25 13:48:45 -0800304void drop_recursive(struct dentry *parent)
305{
Daniel Rosenberg497ac902016-02-03 21:08:21 -0800306 struct dentry *dentry;
Daniel Rosenberg5080d242016-05-18 16:57:10 -0700307 struct sdcardfs_inode_info *info;
308 if (!d_inode(parent))
309 return;
310 info = SDCARDFS_I(d_inode(parent));
Daniel Rosenbergcb1b9452016-08-16 15:19:26 -0700311 spin_lock(&parent->d_lock);
Daniel Rosenberg497ac902016-02-03 21:08:21 -0800312 list_for_each_entry(dentry, &parent->d_subdirs, d_child) {
Daniel Rosenberg5080d242016-05-18 16:57:10 -0700313 if (d_inode(dentry)) {
314 if (SDCARDFS_I(d_inode(parent))->top != SDCARDFS_I(d_inode(dentry))->top) {
Daniel Rosenbergad905252017-01-25 13:48:45 -0800315 drop_recursive(dentry);
316 d_drop(dentry);
317 }
318 }
319 }
320 spin_unlock(&parent->d_lock);
321}
322
323void fixup_top_recursive(struct dentry *parent)
324{
325 struct dentry *dentry;
326 struct sdcardfs_inode_info *info;
327
328 if (!d_inode(parent))
329 return;
330 info = SDCARDFS_I(d_inode(parent));
331 spin_lock(&parent->d_lock);
332 list_for_each_entry(dentry, &parent->d_subdirs, d_child) {
333 if (d_inode(dentry)) {
334 if (SDCARDFS_I(d_inode(parent))->top != SDCARDFS_I(d_inode(dentry))->top) {
Daniel Rosenberg5080d242016-05-18 16:57:10 -0700335 get_derived_permission(parent, dentry);
Daniel Rosenberg90219272016-10-26 20:27:20 -0700336 fixup_tmp_permissions(d_inode(dentry));
Daniel Rosenberg5080d242016-05-18 16:57:10 -0700337 fixup_top_recursive(dentry);
338 }
Daniel Rosenberg497ac902016-02-03 21:08:21 -0800339 }
340 }
Daniel Rosenbergcb1b9452016-08-16 15:19:26 -0700341 spin_unlock(&parent->d_lock);
Daniel Rosenberg497ac902016-02-03 21:08:21 -0800342}
343
Daniel Campello35c9e242015-07-20 16:23:50 -0700344/* main function for updating derived permission */
Daniel Rosenberg497ac902016-02-03 21:08:21 -0800345inline void update_derived_permission_lock(struct dentry *dentry)
Daniel Campello35c9e242015-07-20 16:23:50 -0700346{
347 struct dentry *parent;
348
Daniel Rosenberg63d20762016-12-01 14:36:29 -0800349 if(!dentry || !d_inode(dentry)) {
Daniel Campello35c9e242015-07-20 16:23:50 -0700350 printk(KERN_ERR "sdcardfs: %s: invalid dentry\n", __func__);
351 return;
352 }
353 /* FIXME:
354 * 1. need to check whether the dentry is updated or not
355 * 2. remove the root dentry update
356 */
357 if(IS_ROOT(dentry)) {
Daniel Rosenberg63d20762016-12-01 14:36:29 -0800358 //setup_default_pre_root_state(d_inode(dentry));
Daniel Campello35c9e242015-07-20 16:23:50 -0700359 } else {
360 parent = dget_parent(dentry);
361 if(parent) {
362 get_derived_permission(parent, dentry);
363 dput(parent);
364 }
365 }
Daniel Rosenberg90219272016-10-26 20:27:20 -0700366 fixup_tmp_permissions(d_inode(dentry));
Daniel Campello35c9e242015-07-20 16:23:50 -0700367}
368
369int need_graft_path(struct dentry *dentry)
370{
371 int ret = 0;
372 struct dentry *parent = dget_parent(dentry);
Daniel Rosenberg63d20762016-12-01 14:36:29 -0800373 struct sdcardfs_inode_info *parent_info= SDCARDFS_I(d_inode(parent));
Daniel Campello35c9e242015-07-20 16:23:50 -0700374 struct sdcardfs_sb_info *sbi = SDCARDFS_SB(dentry->d_sb);
Daniel Rosenberg5004c5f2017-01-31 20:07:51 -0800375 struct qstr obb = QSTR_LITERAL("obb");
Daniel Campello35c9e242015-07-20 16:23:50 -0700376
377 if(parent_info->perm == PERM_ANDROID &&
Daniel Rosenberg5004c5f2017-01-31 20:07:51 -0800378 qstr_case_eq(&dentry->d_name, &obb)) {
Daniel Campello35c9e242015-07-20 16:23:50 -0700379
380 /* /Android/obb is the base obbpath of DERIVED_UNIFIED */
Daniel Rosenberg497ac902016-02-03 21:08:21 -0800381 if(!(sbi->options.multiuser == false
Daniel Campello35c9e242015-07-20 16:23:50 -0700382 && parent_info->userid == 0)) {
383 ret = 1;
384 }
385 }
386 dput(parent);
387 return ret;
388}
389
390int is_obbpath_invalid(struct dentry *dent)
391{
392 int ret = 0;
393 struct sdcardfs_dentry_info *di = SDCARDFS_D(dent);
394 struct sdcardfs_sb_info *sbi = SDCARDFS_SB(dent->d_sb);
395 char *path_buf, *obbpath_s;
396
397 /* check the base obbpath has been changed.
398 * this routine can check an uninitialized obb dentry as well.
399 * regarding the uninitialized obb, refer to the sdcardfs_mkdir() */
400 spin_lock(&di->lock);
401 if(di->orig_path.dentry) {
402 if(!di->lower_path.dentry) {
403 ret = 1;
404 } else {
405 path_get(&di->lower_path);
406 //lower_parent = lock_parent(lower_path->dentry);
407
408 path_buf = kmalloc(PATH_MAX, GFP_ATOMIC);
409 if(!path_buf) {
410 ret = 1;
Daniel Rosenberg497ac902016-02-03 21:08:21 -0800411 printk(KERN_ERR "sdcardfs: fail to allocate path_buf in %s.\n", __func__);
Daniel Campello35c9e242015-07-20 16:23:50 -0700412 } else {
413 obbpath_s = d_path(&di->lower_path, path_buf, PATH_MAX);
414 if (d_unhashed(di->lower_path.dentry) ||
Daniel Rosenberg5004c5f2017-01-31 20:07:51 -0800415 !str_case_eq(sbi->obbpath_s, obbpath_s)) {
Daniel Campello35c9e242015-07-20 16:23:50 -0700416 ret = 1;
417 }
418 kfree(path_buf);
419 }
420
421 //unlock_dir(lower_parent);
422 path_put(&di->lower_path);
423 }
424 }
425 spin_unlock(&di->lock);
426 return ret;
427}
428
429int is_base_obbpath(struct dentry *dentry)
430{
431 int ret = 0;
432 struct dentry *parent = dget_parent(dentry);
Daniel Rosenberg63d20762016-12-01 14:36:29 -0800433 struct sdcardfs_inode_info *parent_info= SDCARDFS_I(d_inode(parent));
Daniel Campello35c9e242015-07-20 16:23:50 -0700434 struct sdcardfs_sb_info *sbi = SDCARDFS_SB(dentry->d_sb);
Daniel Rosenberg5004c5f2017-01-31 20:07:51 -0800435 struct qstr q_obb = QSTR_LITERAL("obb");
Daniel Campello35c9e242015-07-20 16:23:50 -0700436
437 spin_lock(&SDCARDFS_D(dentry)->lock);
Daniel Rosenberg497ac902016-02-03 21:08:21 -0800438 if (sbi->options.multiuser) {
439 if(parent_info->perm == PERM_PRE_ROOT &&
Daniel Rosenberg5004c5f2017-01-31 20:07:51 -0800440 qstr_case_eq(&dentry->d_name, &q_obb)) {
Daniel Rosenberg497ac902016-02-03 21:08:21 -0800441 ret = 1;
442 }
443 } else if (parent_info->perm == PERM_ANDROID &&
Daniel Rosenberg5004c5f2017-01-31 20:07:51 -0800444 qstr_case_eq(&dentry->d_name, &q_obb)) {
Daniel Campello35c9e242015-07-20 16:23:50 -0700445 ret = 1;
446 }
Daniel Campello35c9e242015-07-20 16:23:50 -0700447 spin_unlock(&SDCARDFS_D(dentry)->lock);
Daniel Campello35c9e242015-07-20 16:23:50 -0700448 return ret;
449}
450
451/* The lower_path will be stored to the dentry's orig_path
452 * and the base obbpath will be copyed to the lower_path variable.
453 * if an error returned, there's no change in the lower_path
454 * returns: -ERRNO if error (0: no error) */
455int setup_obb_dentry(struct dentry *dentry, struct path *lower_path)
456{
457 int err = 0;
458 struct sdcardfs_sb_info *sbi = SDCARDFS_SB(dentry->d_sb);
459 struct path obbpath;
460
461 /* A local obb dentry must have its own orig_path to support rmdir
462 * and mkdir of itself. Usually, we expect that the sbi->obbpath
463 * is avaiable on this stage. */
464 sdcardfs_set_orig_path(dentry, lower_path);
465
466 err = kern_path(sbi->obbpath_s,
467 LOOKUP_FOLLOW | LOOKUP_DIRECTORY, &obbpath);
468
469 if(!err) {
470 /* the obbpath base has been found */
Daniel Rosenberg497ac902016-02-03 21:08:21 -0800471 printk(KERN_INFO "sdcardfs: the sbi->obbpath is found\n");
Daniel Campello35c9e242015-07-20 16:23:50 -0700472 pathcpy(lower_path, &obbpath);
473 } else {
474 /* if the sbi->obbpath is not available, we can optionally
475 * setup the lower_path with its orig_path.
476 * but, the current implementation just returns an error
477 * because the sdcard daemon also regards this case as
478 * a lookup fail. */
Daniel Rosenberg497ac902016-02-03 21:08:21 -0800479 printk(KERN_INFO "sdcardfs: the sbi->obbpath is not available\n");
Daniel Campello35c9e242015-07-20 16:23:50 -0700480 }
481 return err;
482}
483
484