Linux kernel mirror (for testing)
git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git
kernel
os
linux
Merge tag 'vfs-6.13.ecryptfs.mount.api' of git://git.kernel.org/pub/scm/linux/kernel/git/vfs/vfs
Pull ecryptfs mount api conversion from Christian Brauner:
"Convert ecryptfs to the new mount api"
* tag 'vfs-6.13.ecryptfs.mount.api' of git://git.kernel.org/pub/scm/linux/kernel/git/vfs/vfs:
ecryptfs: Fix spelling mistake "validationg" -> "validating"
ecryptfs: Convert ecryptfs to use the new mount API
ecryptfs: Factor out mount option validation
+204
-195
+204
-195
fs/ecryptfs/main.c
+204
-195
fs/ecryptfs/main.c
···
15
15
#include <linux/module.h>
16
16
#include <linux/namei.h>
17
17
#include <linux/skbuff.h>
18
-
#include <linux/mount.h>
19
18
#include <linux/pagemap.h>
20
19
#include <linux/key.h>
21
-
#include <linux/parser.h>
20
+
#include <linux/fs_context.h>
21
+
#include <linux/fs_parser.h>
22
22
#include <linux/fs_stack.h>
23
23
#include <linux/slab.h>
24
24
#include <linux/magic.h>
···
153
153
}
154
154
}
155
155
156
-
enum { ecryptfs_opt_sig, ecryptfs_opt_ecryptfs_sig,
157
-
ecryptfs_opt_cipher, ecryptfs_opt_ecryptfs_cipher,
158
-
ecryptfs_opt_ecryptfs_key_bytes,
159
-
ecryptfs_opt_passthrough, ecryptfs_opt_xattr_metadata,
160
-
ecryptfs_opt_encrypted_view, ecryptfs_opt_fnek_sig,
161
-
ecryptfs_opt_fn_cipher, ecryptfs_opt_fn_cipher_key_bytes,
162
-
ecryptfs_opt_unlink_sigs, ecryptfs_opt_mount_auth_tok_only,
163
-
ecryptfs_opt_check_dev_ruid,
164
-
ecryptfs_opt_err };
156
+
enum {
157
+
Opt_sig, Opt_ecryptfs_sig, Opt_cipher, Opt_ecryptfs_cipher,
158
+
Opt_ecryptfs_key_bytes, Opt_passthrough, Opt_xattr_metadata,
159
+
Opt_encrypted_view, Opt_fnek_sig, Opt_fn_cipher,
160
+
Opt_fn_cipher_key_bytes, Opt_unlink_sigs, Opt_mount_auth_tok_only,
161
+
Opt_check_dev_ruid
162
+
};
165
163
166
-
static const match_table_t tokens = {
167
-
{ecryptfs_opt_sig, "sig=%s"},
168
-
{ecryptfs_opt_ecryptfs_sig, "ecryptfs_sig=%s"},
169
-
{ecryptfs_opt_cipher, "cipher=%s"},
170
-
{ecryptfs_opt_ecryptfs_cipher, "ecryptfs_cipher=%s"},
171
-
{ecryptfs_opt_ecryptfs_key_bytes, "ecryptfs_key_bytes=%u"},
172
-
{ecryptfs_opt_passthrough, "ecryptfs_passthrough"},
173
-
{ecryptfs_opt_xattr_metadata, "ecryptfs_xattr_metadata"},
174
-
{ecryptfs_opt_encrypted_view, "ecryptfs_encrypted_view"},
175
-
{ecryptfs_opt_fnek_sig, "ecryptfs_fnek_sig=%s"},
176
-
{ecryptfs_opt_fn_cipher, "ecryptfs_fn_cipher=%s"},
177
-
{ecryptfs_opt_fn_cipher_key_bytes, "ecryptfs_fn_key_bytes=%u"},
178
-
{ecryptfs_opt_unlink_sigs, "ecryptfs_unlink_sigs"},
179
-
{ecryptfs_opt_mount_auth_tok_only, "ecryptfs_mount_auth_tok_only"},
180
-
{ecryptfs_opt_check_dev_ruid, "ecryptfs_check_dev_ruid"},
181
-
{ecryptfs_opt_err, NULL}
164
+
static const struct fs_parameter_spec ecryptfs_fs_param_spec[] = {
165
+
fsparam_string ("sig", Opt_sig),
166
+
fsparam_string ("ecryptfs_sig", Opt_ecryptfs_sig),
167
+
fsparam_string ("cipher", Opt_cipher),
168
+
fsparam_string ("ecryptfs_cipher", Opt_ecryptfs_cipher),
169
+
fsparam_u32 ("ecryptfs_key_bytes", Opt_ecryptfs_key_bytes),
170
+
fsparam_flag ("ecryptfs_passthrough", Opt_passthrough),
171
+
fsparam_flag ("ecryptfs_xattr_metadata", Opt_xattr_metadata),
172
+
fsparam_flag ("ecryptfs_encrypted_view", Opt_encrypted_view),
173
+
fsparam_string ("ecryptfs_fnek_sig", Opt_fnek_sig),
174
+
fsparam_string ("ecryptfs_fn_cipher", Opt_fn_cipher),
175
+
fsparam_u32 ("ecryptfs_fn_key_bytes", Opt_fn_cipher_key_bytes),
176
+
fsparam_flag ("ecryptfs_unlink_sigs", Opt_unlink_sigs),
177
+
fsparam_flag ("ecryptfs_mount_auth_tok_only", Opt_mount_auth_tok_only),
178
+
fsparam_flag ("ecryptfs_check_dev_ruid", Opt_check_dev_ruid),
179
+
{}
182
180
};
183
181
184
182
static int ecryptfs_init_global_auth_toks(
···
217
219
mount_crypt_stat->flags |= ECRYPTFS_MOUNT_CRYPT_STAT_INITIALIZED;
218
220
}
219
221
222
+
struct ecryptfs_fs_context {
223
+
/* Mount option status trackers */
224
+
bool check_ruid;
225
+
bool sig_set;
226
+
bool cipher_name_set;
227
+
bool cipher_key_bytes_set;
228
+
bool fn_cipher_name_set;
229
+
bool fn_cipher_key_bytes_set;
230
+
};
231
+
220
232
/**
221
-
* ecryptfs_parse_options
222
-
* @sbi: The ecryptfs super block
223
-
* @options: The options passed to the kernel
224
-
* @check_ruid: set to 1 if device uid should be checked against the ruid
225
-
*
226
-
* Parse mount options:
227
-
* debug=N - ecryptfs_verbosity level for debug output
228
-
* sig=XXX - description(signature) of the key to use
229
-
*
230
-
* Returns the dentry object of the lower-level (lower/interposed)
231
-
* directory; We want to mount our stackable file system on top of
232
-
* that lower directory.
233
+
* ecryptfs_parse_param
234
+
* @fc: The ecryptfs filesystem context
235
+
* @param: The mount parameter to parse
233
236
*
234
237
* The signature of the key to use must be the description of a key
235
238
* already in the keyring. Mounting will fail if the key can not be
···
238
239
*
239
240
* Returns zero on success; non-zero on error
240
241
*/
241
-
static int ecryptfs_parse_options(struct ecryptfs_sb_info *sbi, char *options,
242
-
uid_t *check_ruid)
242
+
static int ecryptfs_parse_param(
243
+
struct fs_context *fc,
244
+
struct fs_parameter *param)
243
245
{
244
-
char *p;
245
-
int rc = 0;
246
-
int sig_set = 0;
247
-
int cipher_name_set = 0;
248
-
int fn_cipher_name_set = 0;
249
-
int cipher_key_bytes;
250
-
int cipher_key_bytes_set = 0;
251
-
int fn_cipher_key_bytes;
252
-
int fn_cipher_key_bytes_set = 0;
246
+
int rc;
247
+
int opt;
248
+
struct fs_parse_result result;
249
+
struct ecryptfs_fs_context *ctx = fc->fs_private;
250
+
struct ecryptfs_sb_info *sbi = fc->s_fs_info;
253
251
struct ecryptfs_mount_crypt_stat *mount_crypt_stat =
254
252
&sbi->mount_crypt_stat;
255
-
substring_t args[MAX_OPT_ARGS];
256
-
int token;
257
-
char *sig_src;
258
-
char *cipher_name_src;
259
-
char *fn_cipher_name_src;
260
-
char *fnek_src;
261
-
char *cipher_key_bytes_src;
262
-
char *fn_cipher_key_bytes_src;
263
-
u8 cipher_code;
264
253
265
-
*check_ruid = 0;
254
+
opt = fs_parse(fc, ecryptfs_fs_param_spec, param, &result);
255
+
if (opt < 0)
256
+
return opt;
266
257
267
-
if (!options) {
268
-
rc = -EINVAL;
269
-
goto out;
270
-
}
271
-
ecryptfs_init_mount_crypt_stat(mount_crypt_stat);
272
-
while ((p = strsep(&options, ",")) != NULL) {
273
-
if (!*p)
274
-
continue;
275
-
token = match_token(p, tokens, args);
276
-
switch (token) {
277
-
case ecryptfs_opt_sig:
278
-
case ecryptfs_opt_ecryptfs_sig:
279
-
sig_src = args[0].from;
280
-
rc = ecryptfs_add_global_auth_tok(mount_crypt_stat,
281
-
sig_src, 0);
282
-
if (rc) {
283
-
printk(KERN_ERR "Error attempting to register "
284
-
"global sig; rc = [%d]\n", rc);
285
-
goto out;
286
-
}
287
-
sig_set = 1;
288
-
break;
289
-
case ecryptfs_opt_cipher:
290
-
case ecryptfs_opt_ecryptfs_cipher:
291
-
cipher_name_src = args[0].from;
292
-
strscpy(mount_crypt_stat->global_default_cipher_name,
293
-
cipher_name_src);
294
-
cipher_name_set = 1;
295
-
break;
296
-
case ecryptfs_opt_ecryptfs_key_bytes:
297
-
cipher_key_bytes_src = args[0].from;
298
-
cipher_key_bytes =
299
-
(int)simple_strtol(cipher_key_bytes_src,
300
-
&cipher_key_bytes_src, 0);
301
-
mount_crypt_stat->global_default_cipher_key_size =
302
-
cipher_key_bytes;
303
-
cipher_key_bytes_set = 1;
304
-
break;
305
-
case ecryptfs_opt_passthrough:
306
-
mount_crypt_stat->flags |=
307
-
ECRYPTFS_PLAINTEXT_PASSTHROUGH_ENABLED;
308
-
break;
309
-
case ecryptfs_opt_xattr_metadata:
310
-
mount_crypt_stat->flags |=
311
-
ECRYPTFS_XATTR_METADATA_ENABLED;
312
-
break;
313
-
case ecryptfs_opt_encrypted_view:
314
-
mount_crypt_stat->flags |=
315
-
ECRYPTFS_XATTR_METADATA_ENABLED;
316
-
mount_crypt_stat->flags |=
317
-
ECRYPTFS_ENCRYPTED_VIEW_ENABLED;
318
-
break;
319
-
case ecryptfs_opt_fnek_sig:
320
-
fnek_src = args[0].from;
321
-
strscpy(mount_crypt_stat->global_default_fnek_sig,
322
-
fnek_src);
323
-
rc = ecryptfs_add_global_auth_tok(
324
-
mount_crypt_stat,
325
-
mount_crypt_stat->global_default_fnek_sig,
326
-
ECRYPTFS_AUTH_TOK_FNEK);
327
-
if (rc) {
328
-
printk(KERN_ERR "Error attempting to register "
329
-
"global fnek sig [%s]; rc = [%d]\n",
330
-
mount_crypt_stat->global_default_fnek_sig,
331
-
rc);
332
-
goto out;
333
-
}
334
-
mount_crypt_stat->flags |=
335
-
(ECRYPTFS_GLOBAL_ENCRYPT_FILENAMES
336
-
| ECRYPTFS_GLOBAL_ENCFN_USE_MOUNT_FNEK);
337
-
break;
338
-
case ecryptfs_opt_fn_cipher:
339
-
fn_cipher_name_src = args[0].from;
340
-
strscpy(mount_crypt_stat->global_default_fn_cipher_name,
341
-
fn_cipher_name_src);
342
-
fn_cipher_name_set = 1;
343
-
break;
344
-
case ecryptfs_opt_fn_cipher_key_bytes:
345
-
fn_cipher_key_bytes_src = args[0].from;
346
-
fn_cipher_key_bytes =
347
-
(int)simple_strtol(fn_cipher_key_bytes_src,
348
-
&fn_cipher_key_bytes_src, 0);
349
-
mount_crypt_stat->global_default_fn_cipher_key_bytes =
350
-
fn_cipher_key_bytes;
351
-
fn_cipher_key_bytes_set = 1;
352
-
break;
353
-
case ecryptfs_opt_unlink_sigs:
354
-
mount_crypt_stat->flags |= ECRYPTFS_UNLINK_SIGS;
355
-
break;
356
-
case ecryptfs_opt_mount_auth_tok_only:
357
-
mount_crypt_stat->flags |=
358
-
ECRYPTFS_GLOBAL_MOUNT_AUTH_TOK_ONLY;
359
-
break;
360
-
case ecryptfs_opt_check_dev_ruid:
361
-
*check_ruid = 1;
362
-
break;
363
-
case ecryptfs_opt_err:
364
-
default:
365
-
printk(KERN_WARNING
366
-
"%s: eCryptfs: unrecognized option [%s]\n",
367
-
__func__, p);
258
+
switch (opt) {
259
+
case Opt_sig:
260
+
case Opt_ecryptfs_sig:
261
+
rc = ecryptfs_add_global_auth_tok(mount_crypt_stat,
262
+
param->string, 0);
263
+
if (rc) {
264
+
printk(KERN_ERR "Error attempting to register "
265
+
"global sig; rc = [%d]\n", rc);
266
+
return rc;
368
267
}
268
+
ctx->sig_set = 1;
269
+
break;
270
+
case Opt_cipher:
271
+
case Opt_ecryptfs_cipher:
272
+
strscpy(mount_crypt_stat->global_default_cipher_name,
273
+
param->string);
274
+
ctx->cipher_name_set = 1;
275
+
break;
276
+
case Opt_ecryptfs_key_bytes:
277
+
mount_crypt_stat->global_default_cipher_key_size =
278
+
result.uint_32;
279
+
ctx->cipher_key_bytes_set = 1;
280
+
break;
281
+
case Opt_passthrough:
282
+
mount_crypt_stat->flags |=
283
+
ECRYPTFS_PLAINTEXT_PASSTHROUGH_ENABLED;
284
+
break;
285
+
case Opt_xattr_metadata:
286
+
mount_crypt_stat->flags |= ECRYPTFS_XATTR_METADATA_ENABLED;
287
+
break;
288
+
case Opt_encrypted_view:
289
+
mount_crypt_stat->flags |= ECRYPTFS_XATTR_METADATA_ENABLED;
290
+
mount_crypt_stat->flags |= ECRYPTFS_ENCRYPTED_VIEW_ENABLED;
291
+
break;
292
+
case Opt_fnek_sig:
293
+
strscpy(mount_crypt_stat->global_default_fnek_sig,
294
+
param->string);
295
+
rc = ecryptfs_add_global_auth_tok(
296
+
mount_crypt_stat,
297
+
mount_crypt_stat->global_default_fnek_sig,
298
+
ECRYPTFS_AUTH_TOK_FNEK);
299
+
if (rc) {
300
+
printk(KERN_ERR "Error attempting to register "
301
+
"global fnek sig [%s]; rc = [%d]\n",
302
+
mount_crypt_stat->global_default_fnek_sig, rc);
303
+
return rc;
304
+
}
305
+
mount_crypt_stat->flags |=
306
+
(ECRYPTFS_GLOBAL_ENCRYPT_FILENAMES
307
+
| ECRYPTFS_GLOBAL_ENCFN_USE_MOUNT_FNEK);
308
+
break;
309
+
case Opt_fn_cipher:
310
+
strscpy(mount_crypt_stat->global_default_fn_cipher_name,
311
+
param->string);
312
+
ctx->fn_cipher_name_set = 1;
313
+
break;
314
+
case Opt_fn_cipher_key_bytes:
315
+
mount_crypt_stat->global_default_fn_cipher_key_bytes =
316
+
result.uint_32;
317
+
ctx->fn_cipher_key_bytes_set = 1;
318
+
break;
319
+
case Opt_unlink_sigs:
320
+
mount_crypt_stat->flags |= ECRYPTFS_UNLINK_SIGS;
321
+
break;
322
+
case Opt_mount_auth_tok_only:
323
+
mount_crypt_stat->flags |= ECRYPTFS_GLOBAL_MOUNT_AUTH_TOK_ONLY;
324
+
break;
325
+
case Opt_check_dev_ruid:
326
+
ctx->check_ruid = 1;
327
+
break;
328
+
default:
329
+
return -EINVAL;
369
330
}
370
-
if (!sig_set) {
331
+
332
+
return 0;
333
+
}
334
+
335
+
static int ecryptfs_validate_options(struct fs_context *fc)
336
+
{
337
+
int rc = 0;
338
+
u8 cipher_code;
339
+
struct ecryptfs_fs_context *ctx = fc->fs_private;
340
+
struct ecryptfs_sb_info *sbi = fc->s_fs_info;
341
+
struct ecryptfs_mount_crypt_stat *mount_crypt_stat;
342
+
343
+
344
+
mount_crypt_stat = &sbi->mount_crypt_stat;
345
+
346
+
if (!ctx->sig_set) {
371
347
rc = -EINVAL;
372
348
ecryptfs_printk(KERN_ERR, "You must supply at least one valid "
373
349
"auth tok signature as a mount "
374
350
"parameter; see the eCryptfs README\n");
375
351
goto out;
376
352
}
377
-
if (!cipher_name_set) {
353
+
if (!ctx->cipher_name_set) {
378
354
int cipher_name_len = strlen(ECRYPTFS_DEFAULT_CIPHER);
379
355
380
356
BUG_ON(cipher_name_len > ECRYPTFS_MAX_CIPHER_NAME_SIZE);
···
357
383
ECRYPTFS_DEFAULT_CIPHER);
358
384
}
359
385
if ((mount_crypt_stat->flags & ECRYPTFS_GLOBAL_ENCRYPT_FILENAMES)
360
-
&& !fn_cipher_name_set)
386
+
&& !ctx->fn_cipher_name_set)
361
387
strcpy(mount_crypt_stat->global_default_fn_cipher_name,
362
388
mount_crypt_stat->global_default_cipher_name);
363
-
if (!cipher_key_bytes_set)
389
+
if (!ctx->cipher_key_bytes_set)
364
390
mount_crypt_stat->global_default_cipher_key_size = 0;
365
391
if ((mount_crypt_stat->flags & ECRYPTFS_GLOBAL_ENCRYPT_FILENAMES)
366
-
&& !fn_cipher_key_bytes_set)
392
+
&& !ctx->fn_cipher_key_bytes_set)
367
393
mount_crypt_stat->global_default_fn_cipher_key_bytes =
368
394
mount_crypt_stat->global_default_cipher_key_size;
369
395
···
427
453
static struct file_system_type ecryptfs_fs_type;
428
454
429
455
/*
430
-
* ecryptfs_mount
431
-
* @fs_type: The filesystem type that the superblock should belong to
432
-
* @flags: The flags associated with the mount
433
-
* @dev_name: The path to mount over
434
-
* @raw_data: The options passed into the kernel
456
+
* ecryptfs_get_tree
457
+
* @fc: The filesystem context
435
458
*/
436
-
static struct dentry *ecryptfs_mount(struct file_system_type *fs_type, int flags,
437
-
const char *dev_name, void *raw_data)
459
+
static int ecryptfs_get_tree(struct fs_context *fc)
438
460
{
439
461
struct super_block *s;
440
-
struct ecryptfs_sb_info *sbi;
462
+
struct ecryptfs_fs_context *ctx = fc->fs_private;
463
+
struct ecryptfs_sb_info *sbi = fc->s_fs_info;
441
464
struct ecryptfs_mount_crypt_stat *mount_crypt_stat;
442
465
struct ecryptfs_dentry_info *root_info;
443
466
const char *err = "Getting sb failed";
444
467
struct inode *inode;
445
468
struct path path;
446
-
uid_t check_ruid;
447
469
int rc;
448
470
449
-
sbi = kmem_cache_zalloc(ecryptfs_sb_info_cache, GFP_KERNEL);
450
-
if (!sbi) {
451
-
rc = -ENOMEM;
452
-
goto out;
453
-
}
454
-
455
-
if (!dev_name) {
471
+
if (!fc->source) {
456
472
rc = -EINVAL;
457
473
err = "Device name cannot be null";
458
474
goto out;
459
475
}
460
476
461
-
rc = ecryptfs_parse_options(sbi, raw_data, &check_ruid);
477
+
mount_crypt_stat = &sbi->mount_crypt_stat;
478
+
rc = ecryptfs_validate_options(fc);
462
479
if (rc) {
463
-
err = "Error parsing options";
480
+
err = "Error validating options";
464
481
goto out;
465
482
}
466
-
mount_crypt_stat = &sbi->mount_crypt_stat;
467
483
468
-
s = sget(fs_type, NULL, set_anon_super, flags, NULL);
484
+
s = sget_fc(fc, NULL, set_anon_super_fc);
469
485
if (IS_ERR(s)) {
470
486
rc = PTR_ERR(s);
471
487
goto out;
···
474
510
s->s_d_op = &ecryptfs_dops;
475
511
476
512
err = "Reading sb failed";
477
-
rc = kern_path(dev_name, LOOKUP_FOLLOW | LOOKUP_DIRECTORY, &path);
513
+
rc = kern_path(fc->source, LOOKUP_FOLLOW | LOOKUP_DIRECTORY, &path);
478
514
if (rc) {
479
515
ecryptfs_printk(KERN_WARNING, "kern_path() failed\n");
480
516
goto out1;
···
493
529
goto out_free;
494
530
}
495
531
496
-
if (check_ruid && !uid_eq(d_inode(path.dentry)->i_uid, current_uid())) {
532
+
if (ctx->check_ruid &&
533
+
!uid_eq(d_inode(path.dentry)->i_uid, current_uid())) {
497
534
rc = -EPERM;
498
535
printk(KERN_ERR "Mount of device (uid: %d) not owned by "
499
536
"requested user (uid: %d)\n",
···
509
544
* Set the POSIX ACL flag based on whether they're enabled in the lower
510
545
* mount.
511
546
*/
512
-
s->s_flags = flags & ~SB_POSIXACL;
547
+
s->s_flags = fc->sb_flags & ~SB_POSIXACL;
513
548
s->s_flags |= path.dentry->d_sb->s_flags & SB_POSIXACL;
514
549
515
550
/**
···
552
587
root_info->lower_path = path;
553
588
554
589
s->s_flags |= SB_ACTIVE;
555
-
return dget(s->s_root);
590
+
fc->root = dget(s->s_root);
591
+
return 0;
556
592
557
593
out_free:
558
594
path_put(&path);
559
595
out1:
560
596
deactivate_locked_super(s);
561
597
out:
562
-
if (sbi) {
598
+
if (sbi)
563
599
ecryptfs_destroy_mount_crypt_stat(&sbi->mount_crypt_stat);
564
-
kmem_cache_free(ecryptfs_sb_info_cache, sbi);
565
-
}
600
+
566
601
printk(KERN_ERR "%s; rc = [%d]\n", err, rc);
567
-
return ERR_PTR(rc);
602
+
return rc;
568
603
}
569
604
570
605
/**
···
583
618
kmem_cache_free(ecryptfs_sb_info_cache, sb_info);
584
619
}
585
620
621
+
static void ecryptfs_free_fc(struct fs_context *fc)
622
+
{
623
+
struct ecryptfs_fs_context *ctx = fc->fs_private;
624
+
struct ecryptfs_sb_info *sbi = fc->s_fs_info;
625
+
626
+
kfree(ctx);
627
+
628
+
if (sbi) {
629
+
ecryptfs_destroy_mount_crypt_stat(&sbi->mount_crypt_stat);
630
+
kmem_cache_free(ecryptfs_sb_info_cache, sbi);
631
+
}
632
+
}
633
+
634
+
static const struct fs_context_operations ecryptfs_context_ops = {
635
+
.free = ecryptfs_free_fc,
636
+
.parse_param = ecryptfs_parse_param,
637
+
.get_tree = ecryptfs_get_tree,
638
+
.reconfigure = NULL,
639
+
};
640
+
641
+
static int ecryptfs_init_fs_context(struct fs_context *fc)
642
+
{
643
+
struct ecryptfs_fs_context *ctx;
644
+
struct ecryptfs_sb_info *sbi = NULL;
645
+
646
+
ctx = kzalloc(sizeof(struct ecryptfs_fs_context), GFP_KERNEL);
647
+
if (!ctx)
648
+
return -ENOMEM;
649
+
sbi = kmem_cache_zalloc(ecryptfs_sb_info_cache, GFP_KERNEL);
650
+
if (!sbi) {
651
+
kfree(ctx);
652
+
ctx = NULL;
653
+
return -ENOMEM;
654
+
}
655
+
656
+
ecryptfs_init_mount_crypt_stat(&sbi->mount_crypt_stat);
657
+
658
+
fc->fs_private = ctx;
659
+
fc->s_fs_info = sbi;
660
+
fc->ops = &ecryptfs_context_ops;
661
+
return 0;
662
+
}
663
+
586
664
static struct file_system_type ecryptfs_fs_type = {
587
665
.owner = THIS_MODULE,
588
666
.name = "ecryptfs",
589
-
.mount = ecryptfs_mount,
667
+
.init_fs_context = ecryptfs_init_fs_context,
668
+
.parameters = ecryptfs_fs_param_spec,
590
669
.kill_sb = ecryptfs_kill_block_super,
591
670
.fs_flags = 0
592
671
};