Line data    Source code

       1             : // SPDX-License-Identifier: GPL-2.0
       2             : #include <linux/fs.h>
       3             : #include <linux/sched.h>
       4             : #include <linux/slab.h>
       5             : #include "internal.h"
       6             : #include "mount.h"
       7             : 
       8             : static DEFINE_SPINLOCK(pin_lock);
       9             : 
      10          26 : void pin_remove(struct fs_pin *pin)
      11             : {
      12          26 :         spin_lock(&pin_lock);
      13          26 :         hlist_del_init(&pin->m_list);
      14          26 :         hlist_del_init(&pin->s_list);
      15          26 :         spin_unlock(&pin_lock);
      16          26 :         spin_lock_irq(&pin->wait.lock);
      17          26 :         pin->done = 1;
      18          26 :         wake_up_locked(&pin->wait);
      19          26 :         spin_unlock_irq(&pin->wait.lock);
      20          26 : }
      21             : 
      22          26 : void pin_insert(struct fs_pin *pin, struct vfsmount *m)
      23             : {
      24          26 :         spin_lock(&pin_lock);
      25          26 :         hlist_add_head(&pin->s_list, &m->mnt_sb->s_pins);
      26          26 :         hlist_add_head(&pin->m_list, &real_mount(m)->mnt_pins);
      27          26 :         spin_unlock(&pin_lock);
      28          26 : }
      29             : 
      30          65 : void pin_kill(struct fs_pin *p)
      31             : {
      32          65 :         wait_queue_entry_t wait;
      33             : 
      34          65 :         if (!p) {
      35          39 :                 rcu_read_unlock();
      36         104 :                 return;
      37             :         }
      38          26 :         init_wait(&wait);
      39          26 :         spin_lock_irq(&p->wait.lock);
      40          26 :         if (likely(!p->done)) {
      41          26 :                 p->done = -1;
      42          26 :                 spin_unlock_irq(&p->wait.lock);
      43          26 :                 rcu_read_unlock();
      44          26 :                 p->kill(p);
      45          26 :                 return;
      46             :         }
      47           0 :         if (p->done > 0) {
      48           0 :                 spin_unlock_irq(&p->wait.lock);
      49           0 :                 rcu_read_unlock();
      50           0 :                 return;
      51             :         }
      52           0 :         __add_wait_queue(&p->wait, &wait);
      53           0 :         while (1) {
      54           0 :                 set_current_state(TASK_UNINTERRUPTIBLE);
      55           0 :                 spin_unlock_irq(&p->wait.lock);
      56           0 :                 rcu_read_unlock();
      57           0 :                 schedule();
      58           0 :                 rcu_read_lock();
      59           0 :                 if (likely(list_empty(&wait.entry)))
      60             :                         break;
      61             :                 /* OK, we know p couldn't have been freed yet */
      62           0 :                 spin_lock_irq(&p->wait.lock);
      63           0 :                 if (p->done > 0) {
      64           0 :                         spin_unlock_irq(&p->wait.lock);
      65             :                         break;
      66             :                 }
      67             :         }
      68           0 :         rcu_read_unlock();
      69             : }
      70             : 
      71           0 : void mnt_pin_kill(struct mount *m)
      72             : {
      73           0 :         while (1) {
      74           0 :                 struct hlist_node *p;
      75           0 :                 rcu_read_lock();
      76           0 :                 p = READ_ONCE(m->mnt_pins.first);
      77           0 :                 if (!p) {
      78           0 :                         rcu_read_unlock();
      79           0 :                         break;
      80             :                 }
      81           0 :                 pin_kill(hlist_entry(p, struct fs_pin, m_list));
      82             :         }
      83           0 : }
      84             : 
      85           0 : void group_pin_kill(struct hlist_head *p)
      86             : {
      87           0 :         while (1) {
      88           0 :                 struct hlist_node *q;
      89           0 :                 rcu_read_lock();
      90           0 :                 q = READ_ONCE(p->first);
      91           0 :                 if (!q) {
      92           0 :                         rcu_read_unlock();
      93           0 :                         break;
      94             :                 }
      95           0 :                 pin_kill(hlist_entry(q, struct fs_pin, s_list));
      96             :         }
      97           0 : }