fs/aufs/debug.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  * debug print functions
  21  */
  22
  23 #include <linux/vt_kern.h>
  24 #include "aufs.h"
  25
  26 int aufs_debug;
  27 MODULE_PARM_DESC(debug, "debug print");
  28 module_param_named(debug, aufs_debug, int, S_IRUGO | S_IWUSR | S_IWGRP);
  29
  30 char *au_plevel = KERN_DEBUG;
  31 #define dpri(fmt, ...) do {                                     \
  32         if ((au_plevel                                          \
  33              && strcmp(au_plevel, KERN_DEBUG))                  \
  34             || au_debug_test())                                 \
  35                 printk("%s" fmt, au_plevel, ##__VA_ARGS__);     \
  36 } while (0)
  37
  38 /* ---------------------------------------------------------------------- */
  39
  40 void au_dpri_whlist(struct au_nhash *whlist)
  41 {
  42         unsigned long ul, n;
  43         struct hlist_head *head;
  44         struct au_vdir_wh *tpos;
  45         struct hlist_node *pos;
  46
  47         n = whlist->nh_num;
  48         head = whlist->nh_head;
  49         for (ul = 0; ul < n; ul++) {
  50                 hlist_for_each_entry(tpos, pos, head, wh_hash)
  51                         dpri("b%d, %.*s, %d\n",
  52                              tpos->wh_bindex,
  53                              tpos->wh_str.len, tpos->wh_str.name,
  54                              tpos->wh_str.len);
  55                 head++;
  56         }
  57 }
  58
  59 void au_dpri_vdir(struct au_vdir *vdir)
  60 {
  61         unsigned long ul;
  62         union au_vdir_deblk_p p;
  63         unsigned char *o;
  64
  65         if (!vdir || IS_ERR(vdir)) {
  66                 dpri("err %ld\n", PTR_ERR(vdir));
  67                 return;
  68         }
  69
  70         dpri("deblk %u, nblk %lu, deblk %p, last{%lu, %p}, ver %lu\n",
  71              vdir->vd_deblk_sz, vdir->vd_nblk, vdir->vd_deblk,
  72              vdir->vd_last.ul, vdir->vd_last.p.deblk, vdir->vd_version);
  73         for (ul = 0; ul < vdir->vd_nblk; ul++) {
  74                 p.deblk = vdir->vd_deblk[ul];
  75                 o = p.deblk;
  76                 dpri("[%lu]: %p\n", ul, o);
  77         }
  78 }
  79
  80 static int do_pri_inode(aufs_bindex_t bindex, struct inode *inode, int hn,
  81                         struct dentry *wh)
  82 {
  83         char *n = NULL;
  84         int l = 0;
  85
  86         if (!inode || IS_ERR(inode)) {
  87                 dpri("i%d: err %ld\n", bindex, PTR_ERR(inode));
  88                 return -1;
  89         }
  90
  91         /* the type of i_blocks depends upon CONFIG_LSF */
  92         BUILD_BUG_ON(sizeof(inode->i_blocks) != sizeof(unsigned long)
  93                      && sizeof(inode->i_blocks) != sizeof(u64));
  94         if (wh) {
  95                 n = (void *)wh->d_name.name;
  96                 l = wh->d_name.len;
  97         }
  98
  99         dpri("i%d: %p, i%lu, %s, cnt %d, nl %u, 0%o, sz %llu, blk %llu,"
 100              " hn %d, ct %lld, np %lu, st 0x%lx, f 0x%x, v %llu, g %x%s%.*s\n",
 101              bindex, inode,
 102              inode->i_ino, inode->i_sb ? au_sbtype(inode->i_sb) : "??",
 103              atomic_read(&inode->i_count), inode->i_nlink, inode->i_mode,
 104              i_size_read(inode), (unsigned long long)inode->i_blocks,
 105              hn, (long long)timespec_to_ns(&inode->i_ctime) & 0x0ffff,
 106              inode->i_mapping ? inode->i_mapping->nrpages : 0,
 107              inode->i_state, inode->i_flags, inode->i_version,
 108              inode->i_generation,
 109              l ? ", wh " : "", l, n);
 110         return 0;
 111 }
 112
 113 void au_dpri_inode(struct inode *inode)
 114 {
 115         struct au_iinfo *iinfo;
 116         aufs_bindex_t bindex;
 117         int err, hn;
 118
 119         err = do_pri_inode(-1, inode, -1, NULL);
 120         if (err || !au_test_aufs(inode->i_sb))
 121                 return;
 122
 123         iinfo = au_ii(inode);
 124         if (!iinfo)
 125                 return;
 126         dpri("i-1: bstart %d, bend %d, gen %d\n",
 127              iinfo->ii_bstart, iinfo->ii_bend, au_iigen(inode));
 128         if (iinfo->ii_bstart < 0)
 129                 return;
 130         hn = 0;
 131         for (bindex = iinfo->ii_bstart; bindex <= iinfo->ii_bend; bindex++) {
 132                 hn = !!au_hn(iinfo->ii_hinode + bindex);
 133                 do_pri_inode(bindex, iinfo->ii_hinode[0 + bindex].hi_inode, hn,
 134                              iinfo->ii_hinode[0 + bindex].hi_whdentry);
 135         }
 136 }
 137
 138 void au_dpri_dalias(struct inode *inode)
 139 {
 140         struct dentry *d;
 141
 142         spin_lock(&inode->i_lock);
 143         list_for_each_entry(d, &inode->i_dentry, d_alias)
 144                 au_dpri_dentry(d);
 145         spin_unlock(&inode->i_lock);
 146 }
 147
 148 static int do_pri_dentry(aufs_bindex_t bindex, struct dentry *dentry)
 149 {
 150         struct dentry *wh = NULL;
 151         int hn;
 152
 153         if (!dentry || IS_ERR(dentry)) {
 154                 dpri("d%d: err %ld\n", bindex, PTR_ERR(dentry));
 155                 return -1;
 156         }
 157         /* do not call dget_parent() here */
 158         /* note: access d_xxx without d_lock */
 159         dpri("d%d: %.*s?/%.*s, %s, cnt %d, flags 0x%x\n",
 160              bindex,
 161              AuDLNPair(dentry->d_parent), AuDLNPair(dentry),
 162              dentry->d_sb ? au_sbtype(dentry->d_sb) : "??",
 163              dentry->d_count, dentry->d_flags);
 164         hn = -1;
 165         if (bindex >= 0 && dentry->d_inode && au_test_aufs(dentry->d_sb)) {
 166                 struct au_iinfo *iinfo = au_ii(dentry->d_inode);
 167                 if (iinfo) {
 168                         hn = !!au_hn(iinfo->ii_hinode + bindex);
 169                         wh = iinfo->ii_hinode[0 + bindex].hi_whdentry;
 170                 }
 171         }
 172         do_pri_inode(bindex, dentry->d_inode, hn, wh);
 173         return 0;
 174 }
 175
 176 void au_dpri_dentry(struct dentry *dentry)
 177 {
 178         struct au_dinfo *dinfo;
 179         aufs_bindex_t bindex;
 180         int err;
 181         struct au_hdentry *hdp;
 182
 183         err = do_pri_dentry(-1, dentry);
 184         if (err || !au_test_aufs(dentry->d_sb))
 185                 return;
 186
 187         dinfo = au_di(dentry);
 188         if (!dinfo)
 189                 return;
 190         dpri("d-1: bstart %d, bend %d, bwh %d, bdiropq %d, gen %d\n",
 191              dinfo->di_bstart, dinfo->di_bend,
 192              dinfo->di_bwh, dinfo->di_bdiropq, au_digen(dentry));
 193         if (dinfo->di_bstart < 0)
 194                 return;
 195         hdp = dinfo->di_hdentry;
 196         for (bindex = dinfo->di_bstart; bindex <= dinfo->di_bend; bindex++)
 197                 do_pri_dentry(bindex, hdp[0 + bindex].hd_dentry);
 198 }
 199
 200 static int do_pri_file(aufs_bindex_t bindex, struct file *file)
 201 {
 202         char a[32];
 203
 204         if (!file || IS_ERR(file)) {
 205                 dpri("f%d: err %ld\n", bindex, PTR_ERR(file));
 206                 return -1;
 207         }
 208         a[0] = 0;
 209         if (bindex < 0
 210             && file->f_dentry
 211             && au_test_aufs(file->f_dentry->d_sb)
 212             && au_fi(file))
 213                 snprintf(a, sizeof(a), ", gen %d, mmapped %d",
 214                          au_figen(file), atomic_read(&au_fi(file)->fi_mmapped));
 215         dpri("f%d: mode 0x%x, flags 0%o, cnt %ld, v %llu, pos %llu%s\n",
 216              bindex, file->f_mode, file->f_flags, (long)file_count(file),
 217              file->f_version, file->f_pos, a);
 218         if (file->f_dentry)
 219                 do_pri_dentry(bindex, file->f_dentry);
 220         return 0;
 221 }
 222
 223 void au_dpri_file(struct file *file)
 224 {
 225         struct au_finfo *finfo;
 226         struct au_fidir *fidir;
 227         struct au_hfile *hfile;
 228         aufs_bindex_t bindex;
 229         int err;
 230
 231         err = do_pri_file(-1, file);
 232         if (err || !file->f_dentry || !au_test_aufs(file->f_dentry->d_sb))
 233                 return;
 234
 235         finfo = au_fi(file);
 236         if (!finfo)
 237                 return;
 238         if (finfo->fi_btop < 0)
 239                 return;
 240         fidir = finfo->fi_hdir;
 241         if (!fidir)
 242                 do_pri_file(finfo->fi_btop, finfo->fi_htop.hf_file);
 243         else
 244                 for (bindex = finfo->fi_btop;
 245                      bindex >= 0 && bindex <= fidir->fd_bbot;
 246                      bindex++) {
 247                         hfile = fidir->fd_hfile + bindex;
 248                         do_pri_file(bindex, hfile ? hfile->hf_file : NULL);
 249                 }
 250 }
 251
 252 static int do_pri_br(aufs_bindex_t bindex, struct au_branch *br)
 253 {
 254         struct vfsmount *mnt;
 255         struct super_block *sb;
 256
 257         if (!br || IS_ERR(br))
 258                 goto out;
 259         mnt = br->br_mnt;
 260         if (!mnt || IS_ERR(mnt))
 261                 goto out;
 262         sb = mnt->mnt_sb;
 263         if (!sb || IS_ERR(sb))
 264                 goto out;
 265
 266         dpri("s%d: {perm 0x%x, id %d, cnt %d, wbr %p}, "
 267              "%s, dev 0x%02x%02x, flags 0x%lx, cnt %d, active %d, "
 268              "xino %d\n",
 269              bindex, br->br_perm, br->br_id, atomic_read(&br->br_count),
 270              br->br_wbr, au_sbtype(sb), MAJOR(sb->s_dev), MINOR(sb->s_dev),
 271              sb->s_flags, sb->s_count,
 272              atomic_read(&sb->s_active), !!br->br_xino.xi_file);
 273         return 0;
 274
 275 out:
 276         dpri("s%d: err %ld\n", bindex, PTR_ERR(br));
 277         return -1;
 278 }
 279
 280 void au_dpri_sb(struct super_block *sb)
 281 {
 282         struct au_sbinfo *sbinfo;
 283         aufs_bindex_t bindex;
 284         int err;
 285         /* to reuduce stack size */
 286         struct {
 287                 struct vfsmount mnt;
 288                 struct au_branch fake;
 289         } *a;
 290
 291         /* this function can be called from magic sysrq */
 292         a = kzalloc(sizeof(*a), GFP_ATOMIC);
 293         if (unlikely(!a)) {
 294                 dpri("no memory\n");
 295                 return;
 296         }
 297
 298         a->mnt.mnt_sb = sb;
 299         a->fake.br_perm = 0;
 300         a->fake.br_mnt = &a->mnt;
 301         a->fake.br_xino.xi_file = NULL;
 302         atomic_set(&a->fake.br_count, 0);
 303         smp_mb(); /* atomic_set */
 304         err = do_pri_br(-1, &a->fake);
 305         kfree(a);
 306         dpri("dev 0x%x\n", sb->s_dev);
 307         if (err || !au_test_aufs(sb))
 308                 return;
 309
 310         sbinfo = au_sbi(sb);
 311         if (!sbinfo)
 312                 return;
 313         dpri("nw %d, gen %u, kobj %d\n",
 314              atomic_read(&sbinfo->si_nowait.nw_len), sbinfo->si_generation,
 315              atomic_read(&sbinfo->si_kobj.kref.refcount));
 316         for (bindex = 0; bindex <= sbinfo->si_bend; bindex++)
 317                 do_pri_br(bindex, sbinfo->si_branch[0 + bindex]);
 318 }
 319
 320 /* ---------------------------------------------------------------------- */
 321
 322 void au_dbg_sleep_jiffy(int jiffy)
 323 {
 324         while (jiffy)
 325                 jiffy = schedule_timeout_uninterruptible(jiffy);
 326 }
 327
 328 void au_dbg_iattr(struct iattr *ia)
 329 {
 330 #define AuBit(name)     if (ia->ia_valid & ATTR_ ## name) \
 331                                 dpri(#name "\n")
 332         AuBit(MODE);
 333         AuBit(UID);
 334         AuBit(GID);
 335         AuBit(SIZE);
 336         AuBit(ATIME);
 337         AuBit(MTIME);
 338         AuBit(CTIME);
 339         AuBit(ATIME_SET);
 340         AuBit(MTIME_SET);
 341         AuBit(FORCE);
 342         AuBit(ATTR_FLAG);
 343         AuBit(KILL_SUID);
 344         AuBit(KILL_SGID);
 345         AuBit(FILE);
 346         AuBit(KILL_PRIV);
 347         AuBit(OPEN);
 348         AuBit(TIMES_SET);
 349 #undef  AuBit
 350         dpri("ia_file %p\n", ia->ia_file);
 351 }
 352
 353 /* ---------------------------------------------------------------------- */
 354
 355 void __au_dbg_verify_dinode(struct dentry *dentry, const char *func, int line)
 356 {
 357         struct inode *h_inode, *inode = dentry->d_inode;
 358         struct dentry *h_dentry;
 359         aufs_bindex_t bindex, bend, bi;
 360
 361         if (!inode /* || au_di(dentry)->di_lsc == AuLsc_DI_TMP */)
 362                 return;
 363
 364         bend = au_dbend(dentry);
 365         bi = au_ibend(inode);
 366         if (bi < bend)
 367                 bend = bi;
 368         bindex = au_dbstart(dentry);
 369         bi = au_ibstart(inode);
 370         if (bi > bindex)
 371                 bindex = bi;
 372
 373         for (; bindex <= bend; bindex++) {
 374                 h_dentry = au_h_dptr(dentry, bindex);
 375                 if (!h_dentry)
 376                         continue;
 377                 h_inode = au_h_iptr(inode, bindex);
 378                 if (unlikely(h_inode != h_dentry->d_inode)) {
 379                         int old = au_debug_test();
 380                         if (!old)
 381                                 au_debug(1);
 382                         AuDbg("b%d, %s:%d\n", bindex, func, line);
 383                         AuDbgDentry(dentry);
 384                         AuDbgInode(inode);
 385                         if (!old)
 386                                 au_debug(0);
 387                         BUG();
 388                 }
 389         }
 390 }
 391
 392 void au_dbg_verify_dir_parent(struct dentry *dentry, unsigned int sigen)
 393 {
 394         struct dentry *parent;
 395
 396         parent = dget_parent(dentry);
 397         AuDebugOn(!S_ISDIR(dentry->d_inode->i_mode));
 398         AuDebugOn(IS_ROOT(dentry));
 399         AuDebugOn(au_digen_test(parent, sigen));
 400         dput(parent);
 401 }
 402
 403 void au_dbg_verify_nondir_parent(struct dentry *dentry, unsigned int sigen)
 404 {
 405         struct dentry *parent;
 406         struct inode *inode;
 407
 408         parent = dget_parent(dentry);
 409         inode = dentry->d_inode;
 410         AuDebugOn(inode && S_ISDIR(dentry->d_inode->i_mode));
 411         AuDebugOn(au_digen_test(parent, sigen));
 412         dput(parent);
 413 }
 414
 415 void au_dbg_verify_gen(struct dentry *parent, unsigned int sigen)
 416 {
 417         int err, i, j;
 418         struct au_dcsub_pages dpages;
 419         struct au_dpage *dpage;
 420         struct dentry **dentries;
 421
 422         err = au_dpages_init(&dpages, GFP_NOFS);
 423         AuDebugOn(err);
 424         err = au_dcsub_pages_rev_aufs(&dpages, parent, /*do_include*/1);
 425         AuDebugOn(err);
 426         for (i = dpages.ndpage - 1; !err && i >= 0; i--) {
 427                 dpage = dpages.dpages + i;
 428                 dentries = dpage->dentries;
 429                 for (j = dpage->ndentry - 1; !err && j >= 0; j--)
 430                         AuDebugOn(au_digen_test(dentries[j], sigen));
 431         }
 432         au_dpages_free(&dpages);
 433 }
 434
 435 void au_dbg_verify_kthread(void)
 436 {
 437         if (au_wkq_test()) {
 438                 au_dbg_blocked();
 439                 /*
 440                  * It may be recursive, but udba=notify between two aufs mounts,
 441                  * where a single ro branch is shared, is not a problem.
 442                  */
 443                 /* WARN_ON(1); */
 444         }
 445 }
 446
 447 /* ---------------------------------------------------------------------- */
 448
 449 void au_debug_sbinfo_init(struct au_sbinfo *sbinfo __maybe_unused)
 450 {
 451 #ifdef AuForceNoPlink
 452         au_opt_clr(sbinfo->si_mntflags, PLINK);
 453 #endif
 454 #ifdef AuForceNoXino
 455         au_opt_clr(sbinfo->si_mntflags, XINO);
 456 #endif
 457 #ifdef AuForceNoRefrof
 458         au_opt_clr(sbinfo->si_mntflags, REFROF);
 459 #endif
 460 #ifdef AuForceHnotify
 461         au_opt_set_udba(sbinfo->si_mntflags, UDBA_HNOTIFY);
 462 #endif
 463 #ifdef AuForceRd0
 464         sbinfo->si_rdblk = 0;
 465         sbinfo->si_rdhash = 0;
 466 #endif
 467 }
 468
 469 int __init au_debug_init(void)
 470 {
 471         aufs_bindex_t bindex;
 472         struct au_vdir_destr destr;
 473
 474         bindex = -1;
 475         AuDebugOn(bindex >= 0);
 476
 477         destr.len = -1;
 478         AuDebugOn(destr.len < NAME_MAX);
 479
 480 #ifdef CONFIG_4KSTACKS
 481         pr_warning("CONFIG_4KSTACKS is defined.\n");
 482 #endif
 483
 484 #ifdef AuForceNoBrs
 485         sysaufs_brs = 0;
 486 #endif
 487
 488         return 0;
 489 }