fs/aufs/loop.c

   1 /*
   2  * Copyright (C) 2005-2012 Junjiro R. Okajima
   3  *
   4  * This program, aufs is free software; you can redistribute it and/or modify
   5  * it under the terms of the GNU General Public License as published by
   6  * the Free Software Foundation; either version 2 of the License, or
   7  * (at your option) any later version.
   8  *
   9  * This program is distributed in the hope that it will be useful,
  10  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  11  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  12  * GNU General Public License for more details.
  13  *
  14  * You should have received a copy of the GNU General Public License
  15  * along with this program; if not, write to the Free Software
  16  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
  17  */
  18
  19 /*
  20  * support for loopback block device as a branch
  21  */
  22
  23 #include <linux/loop.h>
  24 #include "aufs.h"
  25
  26 /*
  27  * test if two lower dentries have overlapping branches.
  28  */
  29 int au_test_loopback_overlap(struct super_block *sb, struct dentry *h_adding)
  30 {
  31         struct super_block *h_sb;
  32         struct loop_device *l;
  33
  34         h_sb = h_adding->d_sb;
  35         if (MAJOR(h_sb->s_dev) != LOOP_MAJOR)
  36                 return 0;
  37
  38         l = h_sb->s_bdev->bd_disk->private_data;
  39         h_adding = l->lo_backing_file->f_dentry;
  40         /*
  41          * h_adding can be local NFS.
  42          * in this case aufs cannot detect the loop.
  43          */
  44         if (unlikely(h_adding->d_sb == sb))
  45                 return 1;
  46         return !!au_test_subdir(h_adding, sb->s_root);
  47 }
  48
  49 /* true if a kernel thread named 'loop[0-9].*' accesses a file */
  50 int au_test_loopback_kthread(void)
  51 {
  52         int ret;
  53         struct task_struct *tsk = current;
  54
  55         ret = 0;
  56         if (tsk->flags & PF_KTHREAD) {
  57                 const char c = tsk->comm[4];
  58                 ret = ('0' <= c && c <= '9'
  59                        && !strncmp(tsk->comm, "loop", 4));
  60         }
  61
  62         return ret;
  63 }
  64
  65 /* ---------------------------------------------------------------------- */
  66
  67 #define au_warn_loopback_step   16
  68 static int au_warn_loopback_nelem = au_warn_loopback_step;
  69 static unsigned long *au_warn_loopback_array;
  70
  71 void au_warn_loopback(struct super_block *h_sb)
  72 {
  73         int i, new_nelem;
  74         unsigned long *a, magic;
  75         static DEFINE_SPINLOCK(spin);
  76
  77         magic = h_sb->s_magic;
  78         spin_lock(&spin);
  79         a = au_warn_loopback_array;
  80         for (i = 0; i < au_warn_loopback_nelem && *a; i++)
  81                 if (a[i] == magic) {
  82                         spin_unlock(&spin);
  83                         return;
  84                 }
  85
  86         /* h_sb is new to us, print it */
  87         if (i < au_warn_loopback_nelem) {
  88                 a[i] = magic;
  89                 goto pr;
  90         }
  91
  92         /* expand the array */
  93         new_nelem = au_warn_loopback_nelem + au_warn_loopback_step;
  94         a = au_kzrealloc(au_warn_loopback_array,
  95                          au_warn_loopback_nelem * sizeof(unsigned long),
  96                          new_nelem * sizeof(unsigned long), GFP_ATOMIC);
  97         if (a) {
  98                 au_warn_loopback_nelem = new_nelem;
  99                 au_warn_loopback_array = a;
 100                 a[i] = magic;
 101                 goto pr;
 102         }
 103
 104         spin_unlock(&spin);
 105         AuWarn1("realloc failed, ignored\n");
 106         return;
 107
 108 pr:
 109         spin_unlock(&spin);
 110         pr_warning("you may want to try another patch for loopback file "
 111                    "on %s(0x%lx) branch\n", au_sbtype(h_sb), magic);
 112 }
 113
 114 int au_loopback_init(void)
 115 {
 116         int err;
 117         struct super_block *sb __maybe_unused;
 118
 119         AuDebugOn(sizeof(sb->s_magic) != sizeof(unsigned long));
 120
 121         err = 0;
 122         au_warn_loopback_array = kcalloc(au_warn_loopback_step,
 123                                          sizeof(unsigned long), GFP_NOFS);
 124         if (unlikely(!au_warn_loopback_array))
 125                 err = -ENOMEM;
 126
 127         return err;
 128 }
 129
 130 void au_loopback_fin(void)
 131 {
 132         kfree(au_warn_loopback_array);
 133 }