1 /*
2 * fs/sdcardfs/sdcardfs.h
3 *
4 * The sdcardfs v2.0
5 * This file system replaces the sdcard daemon on Android
6 * On version 2.0, some of the daemon functions have been ported
7 * to support the multi-user concepts of Android 4.4
8 *
9 * Copyright (c) 2013 Samsung Electronics Co. Ltd
10 * Authors: Daeho Jeong, Woojoong Lee, Seunghwan Hyun,
11 * Sunghwan Yun, Sungjong Seo
12 *
13 * This program has been developed as a stackable file system based on
14 * the WrapFS which written by
15 *
16 * Copyright (c) 1998-2011 Erez Zadok
17 * Copyright (c) 2009 Shrikar Archak
18 * Copyright (c) 2003-2011 Stony Brook University
19 * Copyright (c) 2003-2011 The Research Foundation of SUNY
20 *
21 * This file is dual licensed. It may be redistributed and/or modified
22 * under the terms of the Apache 2.0 License OR version 2 of the GNU
23 * General Public License.
24 */
25
26 #ifndef _SDCARDFS_H_
27 #define _SDCARDFS_H_
28
29 #include <linux/dcache.h>
30 #include <linux/file.h>
31 #include <linux/fs.h>
32 #include <linux/aio.h>
33 #include <linux/kref.h>
34 #include <linux/mm.h>
35 #include <linux/mount.h>
36 #include <linux/namei.h>
37 #include <linux/seq_file.h>
38 #include <linux/statfs.h>
39 #include <linux/fs_stack.h>
40 #include <linux/magic.h>
41 #include <linux/uaccess.h>
42 #include <linux/slab.h>
43 #include <linux/sched.h>
44 #include <linux/types.h>
45 #include <linux/security.h>
46 #include <linux/string.h>
47 #include <linux/list.h>
48 #include "multiuser.h"
49
50 /* the file system name */
51 #define SDCARDFS_NAME "sdcardfs"
52
53 /* sdcardfs root inode number */
54 #define SDCARDFS_ROOT_INO 1
55
56 /* useful for tracking code reachability */
57 #define UDBG pr_default("DBG:%s:%s:%d\n", __FILE__, __func__, __LINE__)
58
59 #define SDCARDFS_DIRENT_SIZE 256
60
61 /* temporary static uid settings for development */
62 #define AID_ROOT 0 /* uid for accessing /mnt/sdcard & extSdcard */
63 #define AID_MEDIA_RW 1023 /* internal media storage write access */
64
65 #define AID_SDCARD_RW 1015 /* external storage write access */
66 #define AID_SDCARD_R 1028 /* external storage read access */
67 #define AID_SDCARD_PICS 1033 /* external storage photos access */
68 #define AID_SDCARD_AV 1034 /* external storage audio/video access */
69 #define AID_SDCARD_ALL 1035 /* access all users external storage */
70 #define AID_MEDIA_OBB 1059 /* obb files */
71
72 #define AID_SDCARD_IMAGE 1057
73
74 #define AID_PACKAGE_INFO 1027
75
76
77 /*
78 * Permissions are handled by our permission function.
79 * We don't want anyone who happens to look at our inode value to prematurely
80 * block access, so store more permissive values. These are probably never
81 * used.
82 */
83 #define fixup_tmp_permissions(x) \
84 do { \
85 (x)->i_uid = make_kuid(&init_user_ns, \
86 SDCARDFS_I(x)->data->d_uid); \
87 (x)->i_gid = make_kgid(&init_user_ns, AID_SDCARD_RW); \
88 (x)->i_mode = ((x)->i_mode & S_IFMT) | 0775;\
89 } while (0)
90
91 /* Android 5.0 support */
92
93 /* Permission mode for a specific node. Controls how file permissions
94 * are derived for children nodes.
95 */
96 typedef enum {
97 /* Nothing special; this node should just inherit from its parent. */
98 PERM_INHERIT,
99 /* This node is one level above a normal root; used for legacy layouts
100 * which use the first level to represent user_id.
101 */
102 PERM_PRE_ROOT,
103 /* This node is "/" */
104 PERM_ROOT,
105 /* This node is "/Android" */
106 PERM_ANDROID,
107 /* This node is "/Android/data" */
108 PERM_ANDROID_DATA,
109 /* This node is "/Android/obb" */
110 PERM_ANDROID_OBB,
111 /* This node is "/Android/media" */
112 PERM_ANDROID_MEDIA,
113 /* This node is "/Android/[data|media|obb]/[package]" */
114 PERM_ANDROID_PACKAGE,
115 /* This node is "/Android/[data|media|obb]/[package]/cache" */
116 PERM_ANDROID_PACKAGE_CACHE,
117 } perm_t;
118
119 struct sdcardfs_sb_info;
120 struct sdcardfs_mount_options;
121 struct sdcardfs_inode_info;
122 struct sdcardfs_inode_data;
123
124 /* Do not directly use this function. Use OVERRIDE_CRED() instead. */
125 const struct cred *override_fsids(struct sdcardfs_sb_info *sbi,
126 struct sdcardfs_inode_data *data);
127 /* Do not directly use this function, use REVERT_CRED() instead. */
128 void revert_fsids(const struct cred *old_cred);
129
130 /* operations vectors defined in specific files */
131 extern const struct file_operations sdcardfs_main_fops;
132 extern const struct file_operations sdcardfs_dir_fops;
133 extern const struct inode_operations sdcardfs_main_iops;
134 extern const struct inode_operations sdcardfs_dir_iops;
135 extern const struct inode_operations sdcardfs_symlink_iops;
136 extern const struct super_operations sdcardfs_sops;
137 extern const struct dentry_operations sdcardfs_ci_dops;
138 extern const struct address_space_operations sdcardfs_aops, sdcardfs_dummy_aops;
139 extern const struct vm_operations_struct sdcardfs_vm_ops;
140
141 extern int sdcardfs_init_inode_cache(void);
142 extern void sdcardfs_destroy_inode_cache(void);
143 extern int sdcardfs_init_dentry_cache(void);
144 extern void sdcardfs_destroy_dentry_cache(void);
145 extern int new_dentry_private_data(struct dentry *dentry);
146 extern void free_dentry_private_data(struct dentry *dentry);
147 extern struct dentry *sdcardfs_lookup(struct inode *dir, struct dentry *dentry,
148 unsigned int flags);
149 extern struct inode *sdcardfs_iget(struct super_block *sb,
150 struct inode *lower_inode, userid_t id);
151 extern int sdcardfs_interpose(struct dentry *dentry, struct super_block *sb,
152 struct path *lower_path, userid_t id);
153
154 /* file private data */
155 struct sdcardfs_file_info {
156 struct file *lower_file;
157 const struct vm_operations_struct *lower_vm_ops;
158 };
159
160 struct sdcardfs_inode_data {
161 struct kref refcount;
162 bool abandoned;
163
164 perm_t perm;
165 userid_t userid;
166 uid_t d_uid;
167 bool under_android;
168 bool under_cache;
169 bool under_obb;
170 };
171
172 /* sdcardfs inode data in memory */
173 struct sdcardfs_inode_info {
174 struct inode *lower_inode;
175 /* state derived based on current position in hierarchy */
176 struct sdcardfs_inode_data *data;
177
178 /* top folder for ownership */
179 spinlock_t top_lock;
180 struct sdcardfs_inode_data *top_data;
181
182 struct inode vfs_inode;
183 };
184
185
186 /* sdcardfs dentry data in memory */
187 struct sdcardfs_dentry_info {
188 spinlock_t lock; /* protects lower_path */
189 struct path lower_path;
190 struct path orig_path;
191 };
192
193 struct sdcardfs_mount_options {
194 uid_t fs_low_uid;
195 gid_t fs_low_gid;
196 userid_t fs_user_id;
197 bool multiuser;
198 bool gid_derivation;
199 bool default_normal;
200 unsigned int reserved_mb;
201 };
202
203 struct sdcardfs_vfsmount_options {
204 gid_t gid;
205 mode_t mask;
206 };
207
208 extern int parse_options_remount(struct super_block *sb, char *options, int silent,
209 struct sdcardfs_vfsmount_options *vfsopts);
210
211 /* sdcardfs super-block data in memory */
212 struct sdcardfs_sb_info {
213 struct super_block *sb;
214 struct super_block *lower_sb;
215 /* derived perm policy : some of options have been added
216 * to sdcardfs_mount_options (Android 4.4 support)
217 */
218 struct sdcardfs_mount_options options;
219 spinlock_t lock; /* protects obbpath */
220 char *obbpath_s;
221 struct path obbpath;
222 void *pkgl_id;
223 struct list_head list;
224 };
225
226 /*
227 * inode to private data
228 *
229 * Since we use containers and the struct inode is _inside_ the
230 * sdcardfs_inode_info structure, SDCARDFS_I will always (given a non-NULL
231 * inode pointer), return a valid non-NULL pointer.
232 */
SDCARDFS_I(const struct inode * inode)233 static inline struct sdcardfs_inode_info *SDCARDFS_I(const struct inode *inode)
234 {
235 return container_of(inode, struct sdcardfs_inode_info, vfs_inode);
236 }
237
238 /* dentry to private data */
239 #define SDCARDFS_D(dent) ((struct sdcardfs_dentry_info *)(dent)->d_fsdata)
240
241 /* superblock to private data */
242 #define SDCARDFS_SB(super) ((struct sdcardfs_sb_info *)(super)->s_fs_info)
243
244 /* file to private Data */
245 #define SDCARDFS_F(file) ((struct sdcardfs_file_info *)((file)->private_data))
246
247 /* file to lower file */
sdcardfs_lower_file(const struct file * f)248 static inline struct file *sdcardfs_lower_file(const struct file *f)
249 {
250 return SDCARDFS_F(f)->lower_file;
251 }
252
sdcardfs_set_lower_file(struct file * f,struct file * val)253 static inline void sdcardfs_set_lower_file(struct file *f, struct file *val)
254 {
255 SDCARDFS_F(f)->lower_file = val;
256 }
257
258 /* inode to lower inode. */
sdcardfs_lower_inode(const struct inode * i)259 static inline struct inode *sdcardfs_lower_inode(const struct inode *i)
260 {
261 return SDCARDFS_I(i)->lower_inode;
262 }
263
sdcardfs_set_lower_inode(struct inode * i,struct inode * val)264 static inline void sdcardfs_set_lower_inode(struct inode *i, struct inode *val)
265 {
266 SDCARDFS_I(i)->lower_inode = val;
267 }
268
269 /* superblock to lower superblock */
sdcardfs_lower_super(const struct super_block * sb)270 static inline struct super_block *sdcardfs_lower_super(
271 const struct super_block *sb)
272 {
273 return SDCARDFS_SB(sb)->lower_sb;
274 }
275
sdcardfs_set_lower_super(struct super_block * sb,struct super_block * val)276 static inline void sdcardfs_set_lower_super(struct super_block *sb,
277 struct super_block *val)
278 {
279 SDCARDFS_SB(sb)->lower_sb = val;
280 }
281
282 /* path based (dentry/mnt) macros */
pathcpy(struct path * dst,const struct path * src)283 static inline void pathcpy(struct path *dst, const struct path *src)
284 {
285 dst->dentry = src->dentry;
286 dst->mnt = src->mnt;
287 }
288
289 /* sdcardfs_get_pname functions calls path_get()
290 * therefore, the caller must call "proper" path_put functions
291 */
292 #define SDCARDFS_DENT_FUNC(pname) \
293 static inline void sdcardfs_get_##pname(const struct dentry *dent, \
294 struct path *pname) \
295 { \
296 spin_lock(&SDCARDFS_D(dent)->lock); \
297 pathcpy(pname, &SDCARDFS_D(dent)->pname); \
298 path_get(pname); \
299 spin_unlock(&SDCARDFS_D(dent)->lock); \
300 return; \
301 } \
302 static inline void sdcardfs_put_##pname(const struct dentry *dent, \
303 struct path *pname) \
304 { \
305 path_put(pname); \
306 return; \
307 } \
308 static inline void sdcardfs_set_##pname(const struct dentry *dent, \
309 struct path *pname) \
310 { \
311 spin_lock(&SDCARDFS_D(dent)->lock); \
312 pathcpy(&SDCARDFS_D(dent)->pname, pname); \
313 spin_unlock(&SDCARDFS_D(dent)->lock); \
314 return; \
315 } \
316 static inline void sdcardfs_reset_##pname(const struct dentry *dent) \
317 { \
318 spin_lock(&SDCARDFS_D(dent)->lock); \
319 SDCARDFS_D(dent)->pname.dentry = NULL; \
320 SDCARDFS_D(dent)->pname.mnt = NULL; \
321 spin_unlock(&SDCARDFS_D(dent)->lock); \
322 return; \
323 } \
324 static inline void sdcardfs_put_reset_##pname(const struct dentry *dent) \
325 { \
326 struct path pname; \
327 spin_lock(&SDCARDFS_D(dent)->lock); \
328 if (SDCARDFS_D(dent)->pname.dentry) { \
329 pathcpy(&pname, &SDCARDFS_D(dent)->pname); \
330 SDCARDFS_D(dent)->pname.dentry = NULL; \
331 SDCARDFS_D(dent)->pname.mnt = NULL; \
332 spin_unlock(&SDCARDFS_D(dent)->lock); \
333 path_put(&pname); \
334 } else \
335 spin_unlock(&SDCARDFS_D(dent)->lock); \
336 return; \
337 }
338
339 SDCARDFS_DENT_FUNC(lower_path)
SDCARDFS_DENT_FUNC(orig_path)340 SDCARDFS_DENT_FUNC(orig_path)
341
342 static inline bool sbinfo_has_sdcard_magic(struct sdcardfs_sb_info *sbinfo)
343 {
344 return sbinfo && sbinfo->sb
345 && sbinfo->sb->s_magic == SDCARDFS_SUPER_MAGIC;
346 }
347
data_get(struct sdcardfs_inode_data * data)348 static inline struct sdcardfs_inode_data *data_get(
349 struct sdcardfs_inode_data *data)
350 {
351 if (data)
352 kref_get(&data->refcount);
353 return data;
354 }
355
top_data_get(struct sdcardfs_inode_info * info)356 static inline struct sdcardfs_inode_data *top_data_get(
357 struct sdcardfs_inode_info *info)
358 {
359 struct sdcardfs_inode_data *top_data;
360
361 spin_lock(&info->top_lock);
362 top_data = data_get(info->top_data);
363 spin_unlock(&info->top_lock);
364 return top_data;
365 }
366
367 extern void data_release(struct kref *ref);
368
data_put(struct sdcardfs_inode_data * data)369 static inline void data_put(struct sdcardfs_inode_data *data)
370 {
371 kref_put(&data->refcount, data_release);
372 }
373
release_own_data(struct sdcardfs_inode_info * info)374 static inline void release_own_data(struct sdcardfs_inode_info *info)
375 {
376 /*
377 * This happens exactly once per inode. At this point, the inode that
378 * originally held this data is about to be freed, and all references
379 * to it are held as a top value, and will likely be released soon.
380 */
381 info->data->abandoned = true;
382 data_put(info->data);
383 }
384
set_top(struct sdcardfs_inode_info * info,struct sdcardfs_inode_info * top_owner)385 static inline void set_top(struct sdcardfs_inode_info *info,
386 struct sdcardfs_inode_info *top_owner)
387 {
388 struct sdcardfs_inode_data *old_top;
389 struct sdcardfs_inode_data *new_top = NULL;
390
391 if (top_owner)
392 new_top = top_data_get(top_owner);
393
394 spin_lock(&info->top_lock);
395 old_top = info->top_data;
396 info->top_data = new_top;
397 if (old_top)
398 data_put(old_top);
399 spin_unlock(&info->top_lock);
400 }
401
get_gid(struct vfsmount * mnt,struct super_block * sb,struct sdcardfs_inode_data * data)402 static inline int get_gid(struct vfsmount *mnt,
403 struct super_block *sb,
404 struct sdcardfs_inode_data *data)
405 {
406 struct sdcardfs_vfsmount_options *vfsopts = mnt->data;
407 struct sdcardfs_sb_info *sbi = SDCARDFS_SB(sb);
408
409 if (vfsopts->gid == AID_SDCARD_RW && !sbi->options.default_normal)
410 /* As an optimization, certain trusted system components only run
411 * as owner but operate across all users. Since we're now handing
412 * out the sdcard_rw GID only to trusted apps, we're okay relaxing
413 * the user boundary enforcement for the default view. The UIDs
414 * assigned to app directories are still multiuser aware.
415 */
416 return AID_SDCARD_RW;
417 else
418 return multiuser_get_uid(data->userid, vfsopts->gid);
419 }
420
get_mode(struct vfsmount * mnt,struct sdcardfs_inode_info * info,struct sdcardfs_inode_data * data)421 static inline int get_mode(struct vfsmount *mnt,
422 struct sdcardfs_inode_info *info,
423 struct sdcardfs_inode_data *data)
424 {
425 int owner_mode;
426 int filtered_mode;
427 struct sdcardfs_vfsmount_options *opts = mnt->data;
428 int visible_mode = 0775 & ~opts->mask;
429
430
431 if (data->perm == PERM_PRE_ROOT) {
432 /* Top of multi-user view should always be visible to ensure
433 * secondary users can traverse inside.
434 */
435 visible_mode = 0711;
436 } else if (data->under_android) {
437 /* Block "other" access to Android directories, since only apps
438 * belonging to a specific user should be in there; we still
439 * leave +x open for the default view.
440 */
441 if (opts->gid == AID_SDCARD_RW)
442 visible_mode = visible_mode & ~0006;
443 else
444 visible_mode = visible_mode & ~0007;
445 }
446 owner_mode = info->lower_inode->i_mode & 0700;
447 filtered_mode = visible_mode & (owner_mode | (owner_mode >> 3) | (owner_mode >> 6));
448 return filtered_mode;
449 }
450
has_graft_path(const struct dentry * dent)451 static inline int has_graft_path(const struct dentry *dent)
452 {
453 int ret = 0;
454
455 spin_lock(&SDCARDFS_D(dent)->lock);
456 if (SDCARDFS_D(dent)->orig_path.dentry != NULL)
457 ret = 1;
458 spin_unlock(&SDCARDFS_D(dent)->lock);
459
460 return ret;
461 }
462
sdcardfs_get_real_lower(const struct dentry * dent,struct path * real_lower)463 static inline void sdcardfs_get_real_lower(const struct dentry *dent,
464 struct path *real_lower)
465 {
466 /* in case of a local obb dentry
467 * the orig_path should be returned
468 */
469 if (has_graft_path(dent))
470 sdcardfs_get_orig_path(dent, real_lower);
471 else
472 sdcardfs_get_lower_path(dent, real_lower);
473 }
474
sdcardfs_put_real_lower(const struct dentry * dent,struct path * real_lower)475 static inline void sdcardfs_put_real_lower(const struct dentry *dent,
476 struct path *real_lower)
477 {
478 if (has_graft_path(dent))
479 sdcardfs_put_orig_path(dent, real_lower);
480 else
481 sdcardfs_put_lower_path(dent, real_lower);
482 }
483
484 extern struct mutex sdcardfs_super_list_lock;
485 extern struct list_head sdcardfs_super_list;
486
487 /* for packagelist.c */
488 extern appid_t get_appid(const char *app_name);
489 extern appid_t get_ext_gid(const char *app_name);
490 extern appid_t is_excluded(const char *app_name, userid_t userid);
491 extern int check_caller_access_to_name(struct inode *parent_node, const struct qstr *name);
492 extern int packagelist_init(void);
493 extern void packagelist_exit(void);
494
495 /* for derived_perm.c */
496 #define BY_NAME (1 << 0)
497 #define BY_USERID (1 << 1)
498 struct limit_search {
499 unsigned int flags;
500 struct qstr name;
501 userid_t userid;
502 };
503
504 extern void setup_derived_state(struct inode *inode, perm_t perm,
505 userid_t userid, uid_t uid);
506 extern void get_derived_permission(struct dentry *parent, struct dentry *dentry);
507 extern void get_derived_permission_new(struct dentry *parent, struct dentry *dentry, const struct qstr *name);
508 extern void fixup_perms_recursive(struct dentry *dentry, struct limit_search *limit);
509
510 extern void update_derived_permission_lock(struct dentry *dentry);
511 void fixup_lower_ownership(struct dentry *dentry, const char *name);
512 extern int need_graft_path(struct dentry *dentry);
513 extern int is_base_obbpath(struct dentry *dentry);
514 extern int is_obbpath_invalid(struct dentry *dentry);
515 extern int setup_obb_dentry(struct dentry *dentry, struct path *lower_path);
516
517 /* locking helpers */
lock_parent(struct dentry * dentry)518 static inline struct dentry *lock_parent(struct dentry *dentry)
519 {
520 struct dentry *dir = dget_parent(dentry);
521
522 mutex_lock_nested(&d_inode(dir)->i_mutex, I_MUTEX_PARENT);
523 return dir;
524 }
525
unlock_dir(struct dentry * dir)526 static inline void unlock_dir(struct dentry *dir)
527 {
528 mutex_unlock(&d_inode(dir)->i_mutex);
529 dput(dir);
530 }
531
prepare_dir(const char * path_s,uid_t uid,gid_t gid,mode_t mode)532 static inline int prepare_dir(const char *path_s, uid_t uid, gid_t gid, mode_t mode)
533 {
534 int err;
535 struct dentry *dent;
536 struct iattr attrs;
537 struct path parent;
538
539 dent = kern_path_locked(path_s, &parent);
540 if (IS_ERR(dent)) {
541 err = PTR_ERR(dent);
542 if (err == -EEXIST)
543 err = 0;
544 goto out_unlock;
545 }
546
547 err = vfs_mkdir2(parent.mnt, d_inode(parent.dentry), dent, mode);
548 if (err) {
549 if (err == -EEXIST)
550 err = 0;
551 goto out_dput;
552 }
553
554 attrs.ia_uid = make_kuid(&init_user_ns, uid);
555 attrs.ia_gid = make_kgid(&init_user_ns, gid);
556 attrs.ia_valid = ATTR_UID | ATTR_GID;
557 mutex_lock(&d_inode(dent)->i_mutex);
558 notify_change2(parent.mnt, dent, &attrs, NULL);
559 mutex_unlock(&d_inode(dent)->i_mutex);
560
561 out_dput:
562 dput(dent);
563
564 out_unlock:
565 /* parent dentry locked by lookup_create */
566 mutex_unlock(&d_inode(parent.dentry)->i_mutex);
567 path_put(&parent);
568 return err;
569 }
570
571 /*
572 * Return 1, if a disk has enough free space, otherwise 0.
573 * We assume that any files can not be overwritten.
574 */
check_min_free_space(struct dentry * dentry,size_t size,int dir)575 static inline int check_min_free_space(struct dentry *dentry, size_t size, int dir)
576 {
577 int err;
578 struct path lower_path;
579 struct kstatfs statfs;
580 u64 avail;
581 struct sdcardfs_sb_info *sbi = SDCARDFS_SB(dentry->d_sb);
582
583 if (sbi->options.reserved_mb) {
584 /* Get fs stat of lower filesystem. */
585 sdcardfs_get_lower_path(dentry, &lower_path);
586 err = vfs_statfs(&lower_path, &statfs);
587 sdcardfs_put_lower_path(dentry, &lower_path);
588
589 if (unlikely(err))
590 return 0;
591
592 /* Invalid statfs informations. */
593 if (unlikely(statfs.f_bsize == 0))
594 return 0;
595
596 /* if you are checking directory, set size to f_bsize. */
597 if (unlikely(dir))
598 size = statfs.f_bsize;
599
600 /* available size */
601 avail = statfs.f_bavail * statfs.f_bsize;
602
603 /* not enough space */
604 if ((u64)size > avail)
605 return 0;
606
607 /* enough space */
608 if ((avail - size) > (sbi->options.reserved_mb * 1024 * 1024))
609 return 1;
610
611 return 0;
612 } else
613 return 1;
614 }
615
616 /*
617 * Copies attrs and maintains sdcardfs managed attrs
618 * Since our permission check handles all special permissions, set those to be open
619 */
sdcardfs_copy_and_fix_attrs(struct inode * dest,const struct inode * src)620 static inline void sdcardfs_copy_and_fix_attrs(struct inode *dest, const struct inode *src)
621 {
622 dest->i_mode = (src->i_mode & S_IFMT) | S_IRWXU | S_IRWXG |
623 S_IROTH | S_IXOTH; /* 0775 */
624 dest->i_uid = make_kuid(&init_user_ns, SDCARDFS_I(dest)->data->d_uid);
625 dest->i_gid = make_kgid(&init_user_ns, AID_SDCARD_RW);
626 dest->i_rdev = src->i_rdev;
627 dest->i_atime = src->i_atime;
628 dest->i_mtime = src->i_mtime;
629 dest->i_ctime = src->i_ctime;
630 dest->i_blkbits = src->i_blkbits;
631 dest->i_flags = src->i_flags;
632 set_nlink(dest, src->i_nlink);
633 }
634
str_case_eq(const char * s1,const char * s2)635 static inline bool str_case_eq(const char *s1, const char *s2)
636 {
637 return !strcasecmp(s1, s2);
638 }
639
str_n_case_eq(const char * s1,const char * s2,size_t len)640 static inline bool str_n_case_eq(const char *s1, const char *s2, size_t len)
641 {
642 return !strncasecmp(s1, s2, len);
643 }
644
qstr_case_eq(const struct qstr * q1,const struct qstr * q2)645 static inline bool qstr_case_eq(const struct qstr *q1, const struct qstr *q2)
646 {
647 return q1->len == q2->len && str_n_case_eq(q1->name, q2->name, q2->len);
648 }
649
650 #define QSTR_LITERAL(string) QSTR_INIT(string, sizeof(string)-1)
651
652 #endif /* not _SDCARDFS_H_ */
653