fs/aufs/debug.c

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