cgroup: update the meaning of cftype->max_write_len

cftype->max_write_len is used to extend the maximum size of writes.
It's interpreted in such a way that the actual maximum size is one
less than the specified value.  The default size is defined by
CGROUP_LOCAL_BUFFER_SIZE.  Its interpretation is quite confusing - its
value is decremented by 1 and then compared for equality with max
size, which means that the actual default size is
CGROUP_LOCAL_BUFFER_SIZE - 2, which is 62 chars.

There's no point in having a limit that low.  Update its definition so
that it means the actual string length sans termination and anything
below PAGE_SIZE-1 is treated as PAGE_SIZE-1.

.max_write_len for "release_agent" is updated to PATH_MAX-1 and
cgroup_release_agent_write() is updated so that the redundant strlen()
check is removed and it uses strlcpy() instead of strcpy().
.max_write_len initializations in blk-throttle.c and cfq-iosched.c are
no longer necessary and removed.  The one in cpuset is kept unchanged
as it's an approximated value to begin with.

This will also make transition to kernfs smoother.

Signed-off-by: Tejun Heo <tj@kernel.org>
Acked-by: Li Zefan <lizefan@huawei.com>

1 files changed, 8 insertions, 10 deletions

diff --git a/kernel/cgroup.c b/kernel/cgroup.c
index eb002c622cd6..fde3633ef389 100644
--- a/kernel/cgroup.c
+++ b/kernel/cgroup.c
@@ -2213,13 +2213,14 @@ static int cgroup_procs_write(struct cgroup_subsys_state *css,
 static int cgroup_release_agent_write(struct cgroup_subsys_state *css,
                                       struct cftype *cft, const char *buffer)
 {
-        BUILD_BUG_ON(sizeof(css->cgroup->root->release_agent_path) < PATH_MAX);
-        if (strlen(buffer) >= PATH_MAX)
-                return -EINVAL;
+        struct cgroupfs_root *root = css->cgroup->root;
+
+        BUILD_BUG_ON(sizeof(root->release_agent_path) < PATH_MAX);
         if (!cgroup_lock_live_group(css->cgroup))
                 return -ENODEV;
         spin_lock(&release_agent_path_lock);
-        strcpy(css->cgroup->root->release_agent_path, buffer);
+        strlcpy(root->release_agent_path, buffer,
+                sizeof(root->release_agent_path));
         spin_unlock(&release_agent_path_lock);
         mutex_unlock(&cgroup_mutex);
         return 0;
@@ -2245,20 +2246,17 @@ static int cgroup_sane_behavior_show(struct seq_file *seq, void *v)
         return 0;
 }
 
-/* A buffer size big enough for numbers or short strings */
-#define CGROUP_LOCAL_BUFFER_SIZE 64
-
 static ssize_t cgroup_file_write(struct file *file, const char __user *userbuf,
                                  size_t nbytes, loff_t *ppos)
 {
         struct cfent *cfe = __d_cfe(file->f_dentry);
         struct cftype *cft = __d_cft(file->f_dentry);
         struct cgroup_subsys_state *css = cfe->css;
-        size_t max_bytes = cft->max_write_len ?: CGROUP_LOCAL_BUFFER_SIZE - 1;
+        size_t max_bytes = max(cft->max_write_len, PAGE_SIZE);
         char *buf;
         int ret;
 
-        if (nbytes >= max_bytes)
+        if (nbytes > max_bytes)
                 return -E2BIG;
 
         buf = kmalloc(nbytes + 1, GFP_KERNEL);
@@ -3919,7 +3917,7 @@ static struct cftype cgroup_base_files[] = {
                 .flags = CFTYPE_INSANE | CFTYPE_ONLY_ON_ROOT,
                 .seq_show = cgroup_release_agent_show,
                 .write_string = cgroup_release_agent_write,
-                .max_write_len = PATH_MAX,
+                .max_write_len = PATH_MAX - 1,
         },
         { }     /* terminate */
 };