Charge loop device i/o to issuing cgroup

PATCH Superseded Dan Schatzberg 5 participants 15 messages Feb 20, 2020 – Feb 24, 2020

Subsystems (5)

Memory management Block layer cgroup memcg +1 more subsystems

lore

Share & tools

lore

Dan Schatzberg

author

2020-02-20 16:51 UTC #0 lore raw

v3 cover Charge loop device i/o to issuing cgroup

Changes since V2:

* Deferred destruction of workqueue items so in the common case there is no allocation needed

Changes since V1:

* Split out and reordered patches so cgroup charging changes are separate from kworker -> workqueue change

* Add mem_css to struct loop_cmd to simplify logic

The loop device runs all i/o to the backing file on a separate kworker thread which results in all i/o being charged to the root cgroup. This allows a loop device to be used to trivially bypass resource limits and other policy. This patch series fixes this gap in accounting.

A simple script to demonstrate this behavior on cgroupv2 machine:

'''
#!/bin/bash
set -e

CGROUP=/sys/fs/cgroup/test.slice
LOOP_DEV=/dev/loop0

if [[ ! -d $CGROUP ]]
then
sudo mkdir $CGROUP
fi

grep oom_kill $CGROUP/memory.events

# Set a memory limit, write more than that limit to tmpfs -> OOM kill sudo unshare -m bash -c "
echo \$\$ > $CGROUP/cgroup.procs;
echo 0 > $CGROUP/memory.swap.max;
echo 64M > $CGROUP/memory.max;
mount -t tmpfs -o size=512m tmpfs /tmp;
dd if=/dev/zero of=/tmp/file bs=1M count=256" || true

grep oom_kill $CGROUP/memory.events

# Set a memory limit, write more than that limit through loopback

# device -> no OOM kill
sudo unshare -m bash -c "
echo \$\$ > $CGROUP/cgroup.procs;
echo 0 > $CGROUP/memory.swap.max;
echo 64M > $CGROUP/memory.max;
mount -t tmpfs -o size=512m tmpfs /tmp;
truncate -s 512m /tmp/backing_file
losetup $LOOP_DEV /tmp/backing_file
dd if=/dev/zero of=$LOOP_DEV bs=1M count=256;
losetup -D $LOOP_DEV" || true

grep oom_kill $CGROUP/memory.events
'''

Naively charging cgroups could result in priority inversions through the single kworker thread in the case where multiple cgroups are reading/writing to the same loop device. This patch series does some minor modification to the loop driver so that each cgroup can make forward progress independently to avoid this inversion.

With this patch series applied, the above script triggers OOM kills when writing through the loop device as expected.

Dan Schatzberg (3):
loop: Use worker per cgroup instead of kworker
mm: Charge active memcg when no mm is set
loop: Charge i/o to mem and blk cg

 drivers/block/loop.c       | 229 +++++++++++++++++++++++++++++++------
 drivers/block/loop.h       |  14 ++-
 include/linux/memcontrol.h |   6 +
 kernel/cgroup/cgroup.c     |   1 +
 mm/memcontrol.c            |  11 +-
 mm/shmem.c                 |   2 +-
 6 files changed, 217 insertions(+), 46 deletions(-)

Signature · 1 line

2.17.1

Dan Schatzberg

author

2020-02-20 16:51 UTC #1 lore raw

PATCH v3 1/3 loop: Use worker per cgroup instead of kworker

Existing uses of loop device may have multiple cgroups reading/writing to the same device. Simply charging resources for I/O to the backing file could result in priority inversion where one cgroup gets synchronously blocked, holding up all other I/O to the loop device.

In order to avoid this priority inversion, we use a single workqueue where each work item is a "struct loop_worker" which contains a queue of struct loop_cmds to issue. The loop device maintains a tree mapping blk css_id -> loop_worker. This allows each cgroup to independently make forward progress issuing I/O to the backing file.

There is also a single queue for I/O associated with the rootcg which can be used in cases of extreme memory shortage where we cannot allocate a loop_worker.

The locking for the tree and queues is fairly heavy handed - we acquire the per-loop-device spinlock any time either is accessed. The existing implementation serializes all I/O through a single thread anyways, so I don't believe this is any worse.

Signed-off-by Dan Schatzberg <[email protected]>

---
 drivers/block/loop.c | 188 +++++++++++++++++++++++++++++++++++++------
 drivers/block/loop.h |  11 ++-
 2 files changed, 170 insertions(+), 29 deletions(-)

drivers/block/loop.c +163 ~~-25~~

index 739b372a5112..78e5005c6742 100644
@@ -70,7 +70,6 @@
 #include <linux/writeback.h>
 #include <linux/completion.h>
 #include <linux/highmem.h>
-#include <linux/kthread.h>
 #include <linux/splice.h>
 #include <linux/sysfs.h>
 #include <linux/miscdevice.h>

@@ -83,6 +82,8 @@
 
 #include <linux/uaccess.h>
 
+#define LOOP_IDLE_WORKER_TIMEOUT (60 * HZ)
+
 static DEFINE_IDR(loop_index_idr);
 static DEFINE_MUTEX(loop_ctl_mutex);

@@ -891,27 +892,101 @@ static void loop_config_discard(struct loop_device *lo)
 
 static void loop_unprepare_queue(struct loop_device *lo)
 {
-	kthread_flush_worker(&lo->worker);
-	kthread_stop(lo->worker_task);
-}
-
-static int loop_kthread_worker_fn(void *worker_ptr)
-{
-	current->flags |= PF_LESS_THROTTLE | PF_MEMALLOC_NOIO;
-	return kthread_worker_fn(worker_ptr);
+	destroy_workqueue(lo->workqueue);
 }
 
 static int loop_prepare_queue(struct loop_device *lo)
 {
-	kthread_init_worker(&lo->worker);
-	lo->worker_task = kthread_run(loop_kthread_worker_fn,
-			&lo->worker, "loop%d", lo->lo_number);
-	if (IS_ERR(lo->worker_task))
+	lo->workqueue = alloc_workqueue("loop%d",
+					WQ_UNBOUND | WQ_FREEZABLE |
+					WQ_MEM_RECLAIM,
+					lo->lo_number);
+	if (IS_ERR(lo->workqueue))
 		return -ENOMEM;
-	set_user_nice(lo->worker_task, MIN_NICE);
+
 	return 0;
 }
 
+struct loop_worker {
+	struct rb_node rb_node;
+	struct work_struct work;
+	struct list_head cmd_list;
+	struct list_head idle_list;
+	struct loop_device *lo;
+	struct cgroup_subsys_state *css;
+	unsigned long last_ran_at;
+};
+
+static void loop_workfn(struct work_struct *work);
+static void loop_rootcg_workfn(struct work_struct *work);
+static void loop_free_idle_workers(struct timer_list *timer);
+
+static void loop_queue_work(struct loop_device *lo, struct loop_cmd *cmd)
+{
+	struct rb_node **node = &(lo->worker_tree.rb_node), *parent = NULL;
+	struct loop_worker *cur_worker, *worker = NULL;
+	struct work_struct *work;
+	struct list_head *cmd_list;
+
+	spin_lock_irq(&lo->lo_lock);
+
+	if (!cmd->css)
+		goto queue_work;
+
+	node = &(lo->worker_tree.rb_node);
+
+	while (*node) {
+		parent = *node;
+		cur_worker = container_of(*node, struct loop_worker, rb_node);
+		if ((long)cur_worker->css == (long)cmd->css) {
+			worker = cur_worker;
+			break;
+		} else if ((long)cur_worker->css < (long)cmd->css) {
+			node = &((*node)->rb_left);
+		} else {
+			node = &((*node)->rb_right);
+		}
+	}
+	if (worker)
+		goto queue_work;
+
+	worker = kzalloc(sizeof(struct loop_worker),
+			GFP_NOWAIT | __GFP_NOWARN);
+	/*
+	 * In the event we cannot allocate a worker, just queue on the
+	 * rootcg worker
+	 */
+	if (!worker)
+		goto queue_work;
+
+	worker->css = cmd->css;
+	css_get(worker->css);
+	INIT_WORK(&worker->work, loop_workfn);
+	INIT_LIST_HEAD(&worker->cmd_list);
+	INIT_LIST_HEAD(&worker->idle_list);
+	worker->lo = lo;
+	rb_link_node(&worker->rb_node, parent, node);
+	rb_insert_color(&worker->rb_node, &lo->worker_tree);
+queue_work:
+	if (worker) {
+		/*
+		 * We need to remove from the idle list here while
+		 * holding the lock so that the idle timer doesn't
+		 * free the worker
+		 */
+		if (!list_empty(&worker->idle_list))
+			list_del_init(&worker->idle_list);
+		work = &worker->work;
+		cmd_list = &worker->cmd_list;
+	} else {
+		work = &lo->rootcg_work;
+		cmd_list = &lo->rootcg_cmd_list;
+	}
+	list_add_tail(&cmd->list_entry, cmd_list);
+	queue_work(lo->workqueue, work);
+	spin_unlock_irq(&lo->lo_lock);
+}
+
 static void loop_update_rotational(struct loop_device *lo)
 {
 	struct file *file = lo->lo_backing_file;

@@ -993,6 +1068,12 @@ static int loop_set_fd(struct loop_device *lo, fmode_t mode,
 
 	set_device_ro(bdev, (lo_flags & LO_FLAGS_READ_ONLY) != 0);
 
+	INIT_WORK(&lo->rootcg_work, loop_rootcg_workfn);
+	INIT_LIST_HEAD(&lo->rootcg_cmd_list);
+	INIT_LIST_HEAD(&lo->idle_worker_list);
+	lo->worker_tree = RB_ROOT;
+	timer_setup(&lo->timer, loop_free_idle_workers,
+		TIMER_DEFERRABLE);
 	lo->use_dio = false;
 	lo->lo_device = bdev;
 	lo->lo_flags = lo_flags;

@@ -1155,6 +1236,7 @@ static int __loop_clr_fd(struct loop_device *lo, bool release)
 	partscan = lo->lo_flags & LO_FLAGS_PARTSCAN && bdev;
 	lo_number = lo->lo_number;
 	loop_unprepare_queue(lo);
+	del_timer_sync(&lo->timer);
 out_unlock:
 	mutex_unlock(&loop_ctl_mutex);
 	if (partscan) {

@@ -1932,7 +2014,7 @@ static blk_status_t loop_queue_rq(struct blk_mq_hw_ctx *hctx,
 	} else
 #endif
 		cmd->css = NULL;
-	kthread_queue_work(&lo->worker, &cmd->work);
+	loop_queue_work(lo, cmd);
 
 	return BLK_STS_OK;
 }

@@ -1958,26 +2040,82 @@ static void loop_handle_cmd(struct loop_cmd *cmd)
 	}
 }
 
-static void loop_queue_work(struct kthread_work *work)
+static void loop_set_timer(struct loop_device *lo)
 {
-	struct loop_cmd *cmd =
-		container_of(work, struct loop_cmd, work);
+	timer_reduce(&lo->timer, jiffies + LOOP_IDLE_WORKER_TIMEOUT);
+}
+
+static void loop_process_work(struct loop_worker *worker,
+			struct list_head *cmd_list, struct loop_device *lo)
+{
+	int orig_flags = current->flags;
+	struct loop_cmd *cmd;
+
+	current->flags |= PF_LESS_THROTTLE | PF_MEMALLOC_NOIO;
+	while (1) {
+		spin_lock_irq(&lo->lo_lock);
+		if (list_empty(cmd_list))
+			break;
+
+		cmd = container_of(
+			cmd_list->next, struct loop_cmd, list_entry);
+		list_del(cmd_list->next);
+		spin_unlock_irq(&lo->lo_lock);
+		loop_handle_cmd(cmd);
+		cond_resched();
+	}
 
-	loop_handle_cmd(cmd);
+	/*
+	 * We only add to the idle list if there are no pending cmds
+	 * *and* the worker will not run again which ensures that it
+	 * is safe to free any worker on the idle list
+	 */
+	if (worker && !work_pending(&worker->work)) {
+		worker->last_ran_at = jiffies;
+		list_add_tail(&worker->idle_list, &lo->idle_worker_list);
+		loop_set_timer(lo);
+	}
+	spin_unlock_irq(&lo->lo_lock);
+	current->flags = orig_flags;
 }
 
-static int loop_init_request(struct blk_mq_tag_set *set, struct request *rq,
-		unsigned int hctx_idx, unsigned int numa_node)
+static void loop_workfn(struct work_struct *work)
 {
-	struct loop_cmd *cmd = blk_mq_rq_to_pdu(rq);
+	struct loop_worker *worker =
+		container_of(work, struct loop_worker, work);
+	loop_process_work(worker, &worker->cmd_list, worker->lo);
+}
 
-	kthread_init_work(&cmd->work, loop_queue_work);
-	return 0;
+static void loop_rootcg_workfn(struct work_struct *work)
+{
+	struct loop_device *lo =
+		container_of(work, struct loop_device, rootcg_work);
+	loop_process_work(NULL, &lo->rootcg_cmd_list, lo);
+}
+
+static void loop_free_idle_workers(struct timer_list *timer)
+{
+	struct loop_device *lo = container_of(timer, struct loop_device, timer);
+	struct loop_worker *pos, *worker;
+
+	spin_lock_irq(&lo->lo_lock);
+	list_for_each_entry_safe(worker, pos, &lo->idle_worker_list,
+				idle_list) {
+		if (time_is_after_jiffies(worker->last_ran_at +
+						LOOP_IDLE_WORKER_TIMEOUT))
+			break;
+		list_del(&worker->idle_list);
+		rb_erase(&worker->rb_node, &lo->worker_tree);
+		css_put(worker->css);
+		kfree(worker);
+	}
+	if (!list_empty(&lo->idle_worker_list))
+		loop_set_timer(lo);
+	spin_unlock_irq(&lo->lo_lock);
 }
 
 static const struct blk_mq_ops loop_mq_ops = {
 	.queue_rq       = loop_queue_rq,
-	.init_request	= loop_init_request,
 	.complete	= lo_complete_rq,
 };

drivers/block/loop.h +7 -4

index af75a5ee4094..87fd0e372227 100644
@@ -14,7 +14,6 @@
 #include <linux/blk-mq.h>
 #include <linux/spinlock.h>
 #include <linux/mutex.h>
-#include <linux/kthread.h>
 #include <uapi/linux/loop.h>
 
 /* Possible states of device */

@@ -54,8 +53,12 @@ struct loop_device {
 
 	spinlock_t		lo_lock;
 	int			lo_state;
-	struct kthread_worker	worker;
-	struct task_struct	*worker_task;
+	struct workqueue_struct *workqueue;
+	struct work_struct      rootcg_work;
+	struct list_head        rootcg_cmd_list;
+	struct list_head        idle_worker_list;
+	struct rb_root          worker_tree;
+	struct timer_list       timer;
 	bool			use_dio;
 	bool			sysfs_inited;

@@ -65,7 +68,7 @@ struct loop_device {
 };
 
 struct loop_cmd {
-	struct kthread_work work;
+	struct list_head list_entry;
 	bool use_aio; /* use AIO interface to handle I/O */
 	atomic_t ref; /* only for aio */
 	long ret;

Signature · 1 line

2.17.1

Johannes Weiner

maintainer

2020-02-20 17:50 UTC #2 lore raw

Re: [PATCH v3 1/3] loop: Use worker per cgroup instead of kworker

Hello Dan,

Quoted 9 lines · Dan Schatzberg

drivers/block/loop.c +9 -0

+static void loop_process_work(struct loop_worker *worker,
+			struct list_head *cmd_list, struct loop_device *lo)
+{
+	int orig_flags = current->flags;
+	struct loop_cmd *cmd;
+
+	current->flags |= PF_LESS_THROTTLE | PF_MEMALLOC_NOIO;
+	while (1) {
+		spin_lock_irq(&lo->lo_lock);

drivers/block/loop.c static void loop_handle_cmd(struct loop_cmd *cmd) · line 2066

Quoted 10 lines

drivers/block/loop.c +10 -0

+		if (list_empty(cmd_list))
+			break;
+
+		cmd = container_of(
+			cmd_list->next, struct loop_cmd, list_entry);
+		list_del(cmd_list->next);
+		spin_unlock_irq(&lo->lo_lock);
+		loop_handle_cmd(cmd);
+		cond_resched();
+	}

The loop structure tripped me up, because it's not immediately obvious that the lock will be held coming out. How about the following to make the lock section stand out visually?

	spin_lock_irq(&lo->lo_lock);
	while (!list_empty(cmd_list)) {
		cmd = container_of(cmd_list->next, struct loop_cmd, list_entry);
		list_del(&cmd->list_entry);
		spin_unlock_irq(&lo->lo_lock);		

		loop_handle_cmd(cmd);
		cond_resched();

		spin_lock_irq(&lo->lo_lock);
	}

Quoted 13 lines

drivers/block/loop.c +12 -1

-	loop_handle_cmd(cmd);
+	/*
+	 * We only add to the idle list if there are no pending cmds
+	 * *and* the worker will not run again which ensures that it
+	 * is safe to free any worker on the idle list
+	 */
+	if (worker && !work_pending(&worker->work)) {
+		worker->last_ran_at = jiffies;
+		list_add_tail(&worker->idle_list, &lo->idle_worker_list);
+		loop_set_timer(lo);
+	}
+	spin_unlock_irq(&lo->lo_lock);
+	current->flags = orig_flags;

Johannes Weiner

maintainer Acked-by on v3 1/3

2020-02-20 22:00 UTC #3 lore raw

Re: [PATCH v3 1/3] loop: Use worker per cgroup instead of kworker

In reply to Dan Schatzberg

Quoted 15 lines · Dan Schatzberg

Existing uses of loop device may have multiple cgroups reading/writing to the same device. Simply charging resources for I/O to the backing file could result in priority inversion where one cgroup gets synchronously blocked, holding up all other I/O to the loop device.
In order to avoid this priority inversion, we use a single workqueue where each work item is a "struct loop_worker" which contains a queue of struct loop_cmds to issue. The loop device maintains a tree mapping blk css_id -> loop_worker. This allows each cgroup to independently make forward progress issuing I/O to the backing file.
There is also a single queue for I/O associated with the rootcg which can be used in cases of extreme memory shortage where we cannot allocate a loop_worker.

Quoted 6 lines

The locking for the tree and queues is fairly heavy handed - we acquire the per-loop-device spinlock any time either is accessed. The existing implementation serializes all I/O through a single thread anyways, so I don't believe this is any worse.
Signed-off-by Dan Schatzberg <[email protected]>

FWIW, this looks good to me, please feel free to include:

Acked-by Johannes Weiner <[email protected]>

I have only some minor style nitpicks (along with the other email I sent earlier on this patch), that would be nice to get fixed:

drivers/block/loop.c static void loop_config_discard(struct loop_device *lo) · line 936

Quoted 13 lines

drivers/block/loop.c +13 -0

+static void loop_queue_work(struct loop_device *lo, struct loop_cmd *cmd)
+{
+	struct rb_node **node = &(lo->worker_tree.rb_node), *parent = NULL;
+	struct loop_worker *cur_worker, *worker = NULL;
+	struct work_struct *work;
+	struct list_head *cmd_list;
+
+	spin_lock_irq(&lo->lo_lock);
+
+	if (!cmd->css)
+		goto queue_work;
+
+	node = &(lo->worker_tree.rb_node);

-> and . are > &, the parentheses aren't necessary.

drivers/block/loop.c static void loop_config_discard(struct loop_device *lo) · line 941

Quoted 4 lines

drivers/block/loop.c +4 -0

+	while (*node) {
+		parent = *node;
+		cur_worker = container_of(*node, struct loop_worker, rb_node);
+		if ((long)cur_worker->css == (long)cmd->css) {

The casts aren't necessary, but they made me doubt myself and look up the types. I wouldn't add them just to be symmetrical with the other arm of the branch.

drivers/block/loop.c static void loop_config_discard(struct loop_device *lo) · line 947

Quoted 6 lines

drivers/block/loop.c +6 -0

+			worker = cur_worker;
+			break;
+		} else if ((long)cur_worker->css < (long)cmd->css) {
+			node = &((*node)->rb_left);
+		} else {
+			node = &((*node)->rb_right);

The outer parentheses aren't necessary.

drivers/block/loop.c static void loop_config_discard(struct loop_device *lo) · line 954

Quoted 7 lines

drivers/block/loop.c +7 -0

+		}
+	}
+	if (worker)
+		goto queue_work;
+
+	worker = kzalloc(sizeof(struct loop_worker), 
+			GFP_NOWAIT | __GFP_NOWARN);

This fits on an 80 character line.

Dan Schatzberg

author

2020-02-20 16:51 UTC #4 lore raw

PATCH v3 2/3 mm: Charge active memcg when no mm is set

In reply to Dan Schatzberg

memalloc_use_memcg() worked for kernel allocations but was silently ignored for user pages.

This patch establishes a precedence order for who gets charged:

1. If there is a memcg associated with the page already, that memcg is charged. This happens during swapin.

2. If an explicit mm is passed, mm->memcg is charged. This happens during page faults, which can be triggered in remote VMs (eg gup).

3. Otherwise consult the current process context. If it has configured a current->active_memcg, use that. Otherwise, current->mm->memcg.

Previously, if a NULL mm was passed to mem_cgroup_try_charge (case 3) it would always charge the root cgroup. Now it looks up the current active_memcg first (falling back to charging the root cgroup if not set).

Signed-off-by Dan Schatzberg <[email protected]>

Acked-by Johannes Weiner <[email protected]>

Acked-by Tejun Heo <[email protected]>

---
 mm/memcontrol.c | 11 ++++++++---
 mm/shmem.c      |  2 +-
 2 files changed, 9 insertions(+), 4 deletions(-)

mm/memcontrol.c +8 -3

index 6f6dc8712e39..b174aff4f069 100644
@@ -6317,7 +6317,8 @@ enum mem_cgroup_protection mem_cgroup_protected(struct mem_cgroup *root,
  * @compound: charge the page as compound or small page
  *
  * Try to charge @page to the memcg that @mm belongs to, reclaiming
- * pages according to @gfp_mask if necessary.
+ * pages according to @gfp_mask if necessary. If @mm is NULL, try to
+ * charge to the active memcg.
  *
  * Returns 0 on success, with *@memcgp pointing to the charged memcg.
  * Otherwise, an error code is returned.

@@ -6361,8 +6362,12 @@ int mem_cgroup_try_charge(struct page *page, struct mm_struct *mm,
 		}
 	}
 
-	if (!memcg)
-		memcg = get_mem_cgroup_from_mm(mm);
+	if (!memcg) {
+		if (!mm)
+			memcg = get_mem_cgroup_from_current();
+		else
+			memcg = get_mem_cgroup_from_mm(mm);
+	}
 
 	ret = try_charge(memcg, gfp_mask, nr_pages);

mm/shmem.c +1 -1

index c8f7540ef048..7c7f5acf89d6 100644
@@ -1766,7 +1766,7 @@ static int shmem_getpage_gfp(struct inode *inode, pgoff_t index,
 	}
 
 	sbinfo = SHMEM_SB(inode->i_sb);
-	charge_mm = vma ? vma->vm_mm : current->mm;
+	charge_mm = vma ? vma->vm_mm : NULL;
 
 	page = find_lock_entry(mapping, index);
 	if (xa_is_value(page)) {

Signature · 1 line

2.17.1

Shakeel Butt

2020-02-20 18:14 UTC #5 lore raw

Re: [PATCH v3 2/3] mm: Charge active memcg when no mm is set

Quoted 6 lines · Dan Schatzberg

memalloc_use_memcg() worked for kernel allocations but was silently ignored for user pages.
This patch establishes a precedence order for who gets charged:

Quoted 8 lines

1. If there is a memcg associated with the page already, that memcg is charged. This happens during swapin.
2. If an explicit mm is passed, mm->memcg is charged. This happens during page faults, which can be triggered in remote VMs (eg gup).
3. Otherwise consult the current process context. If it has configured a current->active_memcg, use that.

What if css_tryget_online(current->active_memcg) in get_mem_cgroup_from_current() fails? Do we want to change this to css_tryget() and even if that fails should we fallback to root_mem_cgroup or current->mm->memcg?

Quoted 60 lines

Otherwise, current->mm->memcg.

Signed-off-by Dan Schatzberg <[email protected]>

Acked-by Johannes Weiner <[email protected]>

Acked-by Tejun Heo <[email protected]>

---
 mm/memcontrol.c | 11 ++++++++---
 mm/shmem.c      |  2 +-
 2 files changed, 9 insertions(+), 4 deletions(-)

mm/memcontrol.c +8 -3

index 6f6dc8712e39..b174aff4f069 100644
@@ -6317,7 +6317,8 @@ enum mem_cgroup_protection mem_cgroup_protected(struct mem_cgroup *root,
  * @compound: charge the page as compound or small page
  *
  * Try to charge @page to the memcg that @mm belongs to, reclaiming
- * pages according to @gfp_mask if necessary.
+ * pages according to @gfp_mask if necessary. If @mm is NULL, try to
+ * charge to the active memcg.
  *
  * Returns 0 on success, with *@memcgp pointing to the charged memcg.
  * Otherwise, an error code is returned.

@@ -6361,8 +6362,12 @@ int mem_cgroup_try_charge(struct page *page, struct mm_struct *mm,
                }
        }
 
-       if (!memcg)
-               memcg = get_mem_cgroup_from_mm(mm);
+       if (!memcg) {
+               if (!mm)
+                       memcg = get_mem_cgroup_from_current();
+               else
+                       memcg = get_mem_cgroup_from_mm(mm);
+       }
 
        ret = try_charge(memcg, gfp_mask, nr_pages);

mm/shmem.c +1 -2

index c8f7540ef048..7c7f5acf89d6 100644
@@ -1766,7 +1766,7 @@ static int shmem_getpage_gfp(struct inode *inode, pgoff_t index,
        }
 
        sbinfo = SHMEM_SB(inode->i_sb);
-       charge_mm = vma ? vma->vm_mm : current->mm;
+       charge_mm = vma ? vma->vm_mm : NULL;
 
        page = find_lock_entry(mapping, index);
        if (xa_is_value(page)) {
--

2.17.1

Johannes Weiner

maintainer

2020-02-20 21:03 UTC #6 lore raw

Re: [PATCH v3 2/3] mm: Charge active memcg when no mm is set

Hey Shakeel!

Quoted 13 lines · Shakeel Butt

Quoted 12 lines · Dan Schatzberg
memalloc_use_memcg() worked for kernel allocations but was silently ignored for user pages.
This patch establishes a precedence order for who gets charged:
1. If there is a memcg associated with the page already, that memcg is charged. This happens during swapin.
2. If an explicit mm is passed, mm->memcg is charged. This happens during page faults, which can be triggered in remote VMs (eg gup).

Quoted 7 lines

Quoted 2 lines
3. Otherwise consult the current process context. If it has configured a current->active_memcg, use that.
What if css_tryget_online(current->active_memcg) in get_mem_cgroup_from_current() fails? Do we want to change this to css_tryget() and even if that fails should we fallback to root_mem_cgroup or current->mm->memcg?

Good questions.

I think we can switch to css_tryget(). If a cgroup goes offline between issuing the IO and the loop layer executing that IO, the resources used could end up in the root instead of the closest ancestor of the offlined group. However, the risk of that actually happening and causing problems is probably pretty small, and the behavior isn't really worse than before Dan's patches.

Would you mind sending a separate patch for this? AFAICS similar concerns apply to all users of foreign charging.

As for tryget failing: can that actually happen? AFAICS, all current users acquire a reference first (get_memcg_from_somewhere()) that they assign to current->active_memcg. We should probably codify this rule and do WARN_ON(!css_tryget()) /* current->active_memcg must hold a ref */

Shakeel Butt

2020-02-20 21:14 UTC #7 lore raw

Re: [PATCH v3 2/3] mm: Charge active memcg when no mm is set

Hi Johannes,

Quoted 25 lines · Johannes Weiner

Hey Shakeel!
Quoted 13 lines · Shakeel Butt
Quoted 12 lines · Dan Schatzberg
memalloc_use_memcg() worked for kernel allocations but was silently ignored for user pages.
This patch establishes a precedence order for who gets charged:
1. If there is a memcg associated with the page already, that memcg is charged. This happens during swapin.
2. If an explicit mm is passed, mm->memcg is charged. This happens during page faults, which can be triggered in remote VMs (eg gup).
Quoted 7 lines
Quoted 2 lines
3. Otherwise consult the current process context. If it has configured a current->active_memcg, use that.
What if css_tryget_online(current->active_memcg) in get_mem_cgroup_from_current() fails? Do we want to change this to css_tryget() and even if that fails should we fallback to root_mem_cgroup or current->mm->memcg?

Quoted 8 lines

Good questions.
I think we can switch to css_tryget(). If a cgroup goes offline between issuing the IO and the loop layer executing that IO, the resources used could end up in the root instead of the closest ancestor of the offlined group. However, the risk of that actually happening and causing problems is probably pretty small, and the behavior isn't really worse than before Dan's patches.

Agreed.

Quoted 3 lines

Would you mind sending a separate patch for this? AFAICS similar concerns apply to all users of foreign charging.

Sure and yes similar concerns apply to other users as well.

Quoted 5 lines

As for tryget failing: can that actually happen? AFAICS, all current users acquire a reference first (get_memcg_from_somewhere()) that they assign to current->active_memcg. We should probably codify this rule and do WARN_ON(!css_tryget()) /* current->active_memcg must hold a ref */

Yes, we should WARN_ON().

Shakeel

Chris Down

Acked-by on v3 2/3

2020-02-20 18:35 UTC #8 lore raw

Re: [PATCH v3 2/3] mm: Charge active memcg when no mm is set

In reply to Dan Schatzberg

Quoted 14 lines · Dan Schatzberg

memalloc_use_memcg() worked for kernel allocations but was silently ignored for user pages.
This patch establishes a precedence order for who gets charged:
1. If there is a memcg associated with the page already, that memcg is charged. This happens during swapin.
2. If an explicit mm is passed, mm->memcg is charged. This happens during page faults, which can be triggered in remote VMs (eg gup).
3. Otherwise consult the current process context. If it has configured a current->active_memcg, use that. Otherwise, current->mm->memcg.

Quoted 8 lines

Previously, if a NULL mm was passed to mem_cgroup_try_charge (case 3) it would always charge the root cgroup. Now it looks up the current active_memcg first (falling back to charging the root cgroup if not set).
Signed-off-by Dan Schatzberg <[email protected]>
Acked-by Johannes Weiner <[email protected]>
Acked-by Tejun Heo <[email protected]>

Acked-by Chris Down <[email protected]>

Thanks! The clarification the v2 thread for this made things clear to me.

Shakeel Butt

Reviewed-by on v3 2/3

2020-02-20 21:15 UTC #9 lore raw

Re: [PATCH v3 2/3] mm: Charge active memcg when no mm is set

In reply to Dan Schatzberg

Quoted 15 lines · Dan Schatzberg

memalloc_use_memcg() worked for kernel allocations but was silently ignored for user pages.
This patch establishes a precedence order for who gets charged:
1. If there is a memcg associated with the page already, that memcg is charged. This happens during swapin.
2. If an explicit mm is passed, mm->memcg is charged. This happens during page faults, which can be triggered in remote VMs (eg gup).
3. Otherwise consult the current process context. If it has configured a current->active_memcg, use that. Otherwise, current->mm->memcg.

Quoted 8 lines

Previously, if a NULL mm was passed to mem_cgroup_try_charge (case 3) it would always charge the root cgroup. Now it looks up the current active_memcg first (falling back to charging the root cgroup if not set).
Signed-off-by Dan Schatzberg <[email protected]>
Acked-by Johannes Weiner <[email protected]>
Acked-by Tejun Heo <[email protected]>

Reviewed-by Shakeel Butt <[email protected]>

Hugh Dickins

maintainer Acked-by on v3 2/3

2020-02-23 19:08 UTC #10 lore raw

Re: [PATCH v3 2/3] mm: Charge active memcg when no mm is set

In reply to Dan Schatzberg

Quoted 14 lines · Dan Schatzberg

memalloc_use_memcg() worked for kernel allocations but was silently ignored for user pages.
This patch establishes a precedence order for who gets charged:
1. If there is a memcg associated with the page already, that memcg is charged. This happens during swapin.
2. If an explicit mm is passed, mm->memcg is charged. This happens during page faults, which can be triggered in remote VMs (eg gup).
3. Otherwise consult the current process context. If it has configured a current->active_memcg, use that. Otherwise, current->mm->memcg.

Quoted 8 lines

Previously, if a NULL mm was passed to mem_cgroup_try_charge (case 3) it would always charge the root cgroup. Now it looks up the current active_memcg first (falling back to charging the root cgroup if not set).
Signed-off-by Dan Schatzberg <[email protected]>
Acked-by Johannes Weiner <[email protected]>
Acked-by Tejun Heo <[email protected]>

Acked-by Hugh Dickins <[email protected]>

Yes, internally we have some further not-yet-upstreamed complications here (mainly, the "memcg=" mount option for all charges on a tmpfs to be charged to that memcg); but what you're doing here does not obstruct adding that later, they fit in well with the hierarchy that you (and Johannes) mapped out above, and it's really an improvement for shmem not to be referring to current there - thanks.

Quoted 49 lines

---
 mm/memcontrol.c | 11 ++++++++---
 mm/shmem.c      |  2 +-
 2 files changed, 9 insertions(+), 4 deletions(-)

mm/memcontrol.c +8 -3

index 6f6dc8712e39..b174aff4f069 100644
@@ -6317,7 +6317,8 @@ enum mem_cgroup_protection mem_cgroup_protected(struct mem_cgroup *root,
  * @compound: charge the page as compound or small page
  *
  * Try to charge @page to the memcg that @mm belongs to, reclaiming
- * pages according to @gfp_mask if necessary.
+ * pages according to @gfp_mask if necessary. If @mm is NULL, try to
+ * charge to the active memcg.
  *
  * Returns 0 on success, with *@memcgp pointing to the charged memcg.
  * Otherwise, an error code is returned.

@@ -6361,8 +6362,12 @@ int mem_cgroup_try_charge(struct page *page, struct mm_struct *mm,
 		}
 	}
 
-	if (!memcg)
-		memcg = get_mem_cgroup_from_mm(mm);
+	if (!memcg) {
+		if (!mm)
+			memcg = get_mem_cgroup_from_current();
+		else
+			memcg = get_mem_cgroup_from_mm(mm);
+	}
 
 	ret = try_charge(memcg, gfp_mask, nr_pages);

mm/shmem.c +1 -1

index c8f7540ef048..7c7f5acf89d6 100644
@@ -1766,7 +1766,7 @@ static int shmem_getpage_gfp(struct inode *inode, pgoff_t index,
 	}
 
 	sbinfo = SHMEM_SB(inode->i_sb);
-	charge_mm = vma ? vma->vm_mm : current->mm;
+	charge_mm = vma ? vma->vm_mm : NULL;
 
 	page = find_lock_entry(mapping, index);
 	if (xa_is_value(page)) {

Signature · 1 line

2.17.1

Hugh Dickins

maintainer

2020-02-24 01:11 UTC #11 lore raw

Re: [PATCH v3 2/3] mm: Charge active memcg when no mm is set

Quoted 25 lines · Hugh Dickins

Quoted 14 lines · Dan Schatzberg
memalloc_use_memcg() worked for kernel allocations but was silently ignored for user pages.
This patch establishes a precedence order for who gets charged:
1. If there is a memcg associated with the page already, that memcg is charged. This happens during swapin.
2. If an explicit mm is passed, mm->memcg is charged. This happens during page faults, which can be triggered in remote VMs (eg gup).
3. Otherwise consult the current process context. If it has configured a current->active_memcg, use that. Otherwise, current->mm->memcg.
Quoted 8 lines
Previously, if a NULL mm was passed to mem_cgroup_try_charge (case 3) it would always charge the root cgroup. Now it looks up the current active_memcg first (falling back to charging the root cgroup if not set).
Signed-off-by Dan Schatzberg <[email protected]>
Acked-by Johannes Weiner <[email protected]>
Acked-by Tejun Heo <[email protected]>

Quoted 8 lines

Acked-by Hugh Dickins <[email protected]>
Yes, internally we have some further not-yet-upstreamed complications here (mainly, the "memcg=" mount option for all charges on a tmpfs to be charged to that memcg); but what you're doing here does not obstruct adding that later, they fit in well with the hierarchy that you (and Johannes) mapped out above, and it's really an improvement for shmem not to be referring to current there - thanks.

I acked slightly too soon. There are two other uses of "try_charge" in mm/shmem.c: we can be confident that the userfaultfd one knows what mm it's dealing with, but the shmem_swapin_page() instance has a similar use of current->mm, that you also want to adjust to NULL, don't you?

Hugh

Dan Schatzberg

author

2020-02-24 21:37 UTC #12 lore raw

Re: [PATCH v3 2/3] mm: Charge active memcg when no mm is set

Quoted 35 lines · Hugh Dickins

Quoted 25 lines · Hugh Dickins
Quoted 14 lines · Dan Schatzberg
memalloc_use_memcg() worked for kernel allocations but was silently ignored for user pages.
This patch establishes a precedence order for who gets charged:
1. If there is a memcg associated with the page already, that memcg is charged. This happens during swapin.
2. If an explicit mm is passed, mm->memcg is charged. This happens during page faults, which can be triggered in remote VMs (eg gup).
3. Otherwise consult the current process context. If it has configured a current->active_memcg, use that. Otherwise, current->mm->memcg.
Quoted 8 lines
Previously, if a NULL mm was passed to mem_cgroup_try_charge (case 3) it would always charge the root cgroup. Now it looks up the current active_memcg first (falling back to charging the root cgroup if not set).
Signed-off-by Dan Schatzberg <[email protected]>
Acked-by Johannes Weiner <[email protected]>
Acked-by Tejun Heo <[email protected]>
Quoted 8 lines
Acked-by Hugh Dickins <[email protected]>
Yes, internally we have some further not-yet-upstreamed complications here (mainly, the "memcg=" mount option for all charges on a tmpfs to be charged to that memcg); but what you're doing here does not obstruct adding that later, they fit in well with the hierarchy that you (and Johannes) mapped out above, and it's really an improvement for shmem not to be referring to current there - thanks.

Quoted 6 lines

I acked slightly too soon. There are two other uses of "try_charge" in mm/shmem.c: we can be confident that the userfaultfd one knows what mm it's dealing with, but the shmem_swapin_page() instance has a similar use of current->mm, that you also want to adjust to NULL, don't you?
Hugh

Yes, you're right. I'll change shmem_swapin_page as well

Dan Schatzberg

author

2020-02-20 16:51 UTC #13 lore raw

PATCH v3 3/3 loop: Charge i/o to mem and blk cg

In reply to Dan Schatzberg

The current code only associates with the existing blkcg when aio is used to access the backing file. This patch covers all types of i/o to the backing file and also associates the memcg so if the backing file is on tmpfs, memory is charged appropriately.

This patch also exports cgroup_get_e_css so it can be used by the loop module.

Signed-off-by Dan Schatzberg <[email protected]>

---
 drivers/block/loop.c       | 59 ++++++++++++++++++++++++--------------
 drivers/block/loop.h       |  3 +-
 include/linux/memcontrol.h |  6 ++++
 kernel/cgroup/cgroup.c     |  1 +
 4 files changed, 47 insertions(+), 22 deletions(-)

drivers/block/loop.c +38 ~~-21~~

index 78e5005c6742..cc091a66b0d0 100644
@@ -77,6 +77,7 @@
 #include <linux/uio.h>
 #include <linux/ioprio.h>
 #include <linux/blk-cgroup.h>
+#include <linux/sched/mm.h>
 
 #include "loop.h"

@@ -134,7 +135,7 @@ static struct loop_func_table xor_funcs = {
 	.number = LO_CRYPT_XOR,
 	.transfer = transfer_xor,
 	.init = xor_init
-}; 
+};
 
 /* xfer_funcs[0] is special - its release function is never called */
 static struct loop_func_table *xfer_funcs[MAX_LO_CRYPT] = {

@@ -504,8 +505,6 @@ static void lo_rw_aio_complete(struct kiocb *iocb, long ret, long ret2)
 {
 	struct loop_cmd *cmd = container_of(iocb, struct loop_cmd, iocb);
 
-	if (cmd->css)
-		css_put(cmd->css);
 	cmd->ret = ret;
 	lo_rw_aio_do_completion(cmd);
 }

@@ -566,8 +565,6 @@ static int lo_rw_aio(struct loop_device *lo, struct loop_cmd *cmd,
 	cmd->iocb.ki_complete = lo_rw_aio_complete;
 	cmd->iocb.ki_flags = IOCB_DIRECT;
 	cmd->iocb.ki_ioprio = IOPRIO_PRIO_VALUE(IOPRIO_CLASS_NONE, 0);
-	if (cmd->css)
-		kthread_associate_blkcg(cmd->css);
 
 	if (rw == WRITE)
 		ret = call_write_iter(file, &cmd->iocb, &iter);

@@ -575,7 +572,6 @@ static int lo_rw_aio(struct loop_device *lo, struct loop_cmd *cmd,
 		ret = call_read_iter(file, &cmd->iocb, &iter);
 
 	lo_rw_aio_do_completion(cmd);
-	kthread_associate_blkcg(NULL);
 
 	if (ret != -EIOCBQUEUED)
 		cmd->iocb.ki_complete(&cmd->iocb, ret, 0);

@@ -913,7 +909,7 @@ struct loop_worker {
 	struct list_head cmd_list;
 	struct list_head idle_list;
 	struct loop_device *lo;
-	struct cgroup_subsys_state *css;
+	struct cgroup_subsys_state *blkcg_css;
 	unsigned long last_ran_at;
 };

@@ -930,7 +926,7 @@ static void loop_queue_work(struct loop_device *lo, struct loop_cmd *cmd)
 
 	spin_lock_irq(&lo->lo_lock);
 
-	if (!cmd->css)
+	if (!cmd->blkcg_css)
 		goto queue_work;
 
 	node = &(lo->worker_tree.rb_node);

@@ -938,10 +934,10 @@ static void loop_queue_work(struct loop_device *lo, struct loop_cmd *cmd)
 	while (*node) {
 		parent = *node;
 		cur_worker = container_of(*node, struct loop_worker, rb_node);
-		if ((long)cur_worker->css == (long)cmd->css) {
+		if ((long)cur_worker->blkcg_css == (long)cmd->blkcg_css) {
 			worker = cur_worker;
 			break;
-		} else if ((long)cur_worker->css < (long)cmd->css) {
+		} else if ((long)cur_worker->blkcg_css < (long)cmd->blkcg_css) {
 			node = &((*node)->rb_left);
 		} else {
 			node = &((*node)->rb_right);

@@ -954,13 +950,16 @@ static void loop_queue_work(struct loop_device *lo, struct loop_cmd *cmd)
 			GFP_NOWAIT | __GFP_NOWARN);
 	/*
 	 * In the event we cannot allocate a worker, just queue on the
-	 * rootcg worker
+	 * rootcg worker and issue the I/O as the rootcg
 	 */
-	if (!worker)
+	if (!worker) {
+		cmd->blkcg_css = NULL;
+		cmd->memcg_css = NULL;
 		goto queue_work;
+	}
 
-	worker->css = cmd->css;
-	css_get(worker->css);
+	worker->blkcg_css = cmd->blkcg_css;
+	css_get(worker->blkcg_css);
 	INIT_WORK(&worker->work, loop_workfn);
 	INIT_LIST_HEAD(&worker->cmd_list);
 	INIT_LIST_HEAD(&worker->idle_list);

@@ -2007,13 +2006,18 @@ static blk_status_t loop_queue_rq(struct blk_mq_hw_ctx *hctx,
 	}
 
 	/* always use the first bio's css */
+	cmd->blkcg_css = NULL;
+	cmd->memcg_css = NULL;
 #ifdef CONFIG_BLK_CGROUP
-	if (cmd->use_aio && rq->bio && rq->bio->bi_blkg) {
-		cmd->css = &bio_blkcg(rq->bio)->css;
-		css_get(cmd->css);
-	} else
+	if (rq->bio && rq->bio->bi_blkg) {
+		cmd->blkcg_css = &bio_blkcg(rq->bio)->css;
+#ifdef CONFIG_MEMCG
+		cmd->memcg_css =
+			cgroup_get_e_css(cmd->blkcg_css->cgroup,
+					&memory_cgrp_subsys);
+#endif
+	}
 #endif
-		cmd->css = NULL;
 	loop_queue_work(lo, cmd);
 
 	return BLK_STS_OK;

@@ -2031,8 +2035,21 @@ static void loop_handle_cmd(struct loop_cmd *cmd)
 		goto failed;
 	}
 
+	if (cmd->blkcg_css)
+		kthread_associate_blkcg(cmd->blkcg_css);
+	if (cmd->memcg_css)
+		memalloc_use_memcg(mem_cgroup_from_css(cmd->memcg_css));
+
 	ret = do_req_filebacked(lo, rq);
- failed:
+
+	if (cmd->blkcg_css)
+		kthread_associate_blkcg(NULL);
+
+	if (cmd->memcg_css) {
+		memalloc_unuse_memcg();
+		css_put(cmd->memcg_css);
+	}
+failed:
 	/* complete non-aio request */
 	if (!cmd->use_aio || ret) {
 		cmd->ret = ret ? -EIO : 0;

@@ -2106,7 +2123,7 @@ static void loop_free_idle_workers(struct timer_list *timer)
 			break;
 		list_del(&worker->idle_list);
 		rb_erase(&worker->rb_node, &lo->worker_tree);
-		css_put(worker->css);
+		css_put(worker->blkcg_css);
 		kfree(worker);
 	}
 	if (!list_empty(&lo->idle_worker_list))

drivers/block/loop.h +2 -1

index 87fd0e372227..3e65acf7a0e9 100644
@@ -74,7 +74,8 @@ struct loop_cmd {
 	long ret;
 	struct kiocb iocb;
 	struct bio_vec *bvec;
-	struct cgroup_subsys_state *css;
+	struct cgroup_subsys_state *blkcg_css;
+	struct cgroup_subsys_state *memcg_css;
 };
 
 /* Support for loadable transfer modules */

include/linux/memcontrol.h +6 -0

index a7a0a1a5c8d5..aeb51f2ded46 100644
@@ -922,6 +922,12 @@ static inline struct mem_cgroup *get_mem_cgroup_from_page(struct page *page)
 	return NULL;
 }
 
+static inline
+struct mem_cgroup *mem_cgroup_from_css(struct cgroup_subsys_state *css)
+{
+	return NULL;
+}
+
 static inline void mem_cgroup_put(struct mem_cgroup *memcg)
 {
 }

kernel/cgroup/cgroup.c +1 -0

index 75f687301bbf..c3896c2e0942 100644
@@ -587,6 +587,7 @@ struct cgroup_subsys_state *cgroup_get_e_css(struct cgroup *cgrp,
 	rcu_read_unlock();
 	return css;
 }
+EXPORT_SYMBOL_GPL(cgroup_get_e_css);
 
 static void cgroup_get_live(struct cgroup *cgrp)
 {

Signature · 1 line

2.17.1

Johannes Weiner

maintainer Acked-by on v3 3/3

2020-02-20 22:02 UTC #14 lore raw

Re: [PATCH v3 3/3] loop: Charge i/o to mem and blk cg

Quoted 9 lines · Dan Schatzberg

The current code only associates with the existing blkcg when aio is used to access the backing file. This patch covers all types of i/o to the backing file and also associates the memcg so if the backing file is on tmpfs, memory is charged appropriately.
This patch also exports cgroup_get_e_css so it can be used by the loop module.
Signed-off-by Dan Schatzberg <[email protected]>

The cgroup bits look good to me.

Acked-by Johannes Weiner <[email protected]>