NetBSD-Bugs archive
[Date Prev][Date Next][Thread Prev][Thread Next][Date Index][Thread Index][Old Index]

Re: kern/60746: kernel diagnostic assertion "ino >= LFS_IFILE_INUM" failed: file "../../../../ufs/lfs/lfs_vfsops.c", line 1800

The following reply was made to PR kern/60746; it has been noted by GNATS.

From: Konrad Schroder <perseant%hhhh.org@localhost>
To: Shinichi Doyashiki <clare%csel.org@localhost>, gnats-bugs%netbsd.org@localhost
Cc: 
Subject: Re: kern/60746: kernel diagnostic assertion "ino >= LFS_IFILE_INUM"
 failed: file "../../../../ufs/lfs/lfs_vfsops.c", line 1800
Date: Fri, 25 Sep 2026 17:27:57 -0700

 This is a multi-part message in MIME format.
 --------------dxiTaDNF4uWZ14qRRrTgAVFn
 Content-Type: text/plain; charset=UTF-8; format=flowed
 Content-Transfer-Encoding: 8bit
 
 On 9/25/2026 3:50 PM, Shinichi Doyashiki wrote:
 > [  86.8886575] ifile dirty lbn 0x9 flags 0x4000 cflags 0x0 oflags 0x80
 > [  86.8986565] ifile dirty lbn 0xb flags 0x4000 cflags 0x0 oflags 0x80
 > [  86.9086571] ifile dirty lbn 0xd flags 0x4000 cflags 0x0 oflags 0x80
 > [  86.9186564] ifile dirty lbn 0xe flags 0x4000 cflags 0x0 oflags 0x80
 > [  86.9286590] ifile dirty lbn 0x10 flags 0x4000 cflags 0x0 oflags 0x80
 > [  86.9386578] ifile dirty lbn 0x12 flags 0x4000 cflags 0x0 oflags 0x80
 > [  86.9486576] ifile dirty lbn 0x14 flags 0x4000 cflags 0x0 oflags 0x80
 > [  86.9586575] ifile dirty lbn 0x16 flags 0x4000 cflags 0x0 oflags 0x80
 > [  86.9686574] panic: lfs_writeinode: looping
 
 Aha!  We'd been assuming that this looping behavior was caused by a 
 buffer being held busy by another process, and before it could have 
 been.  But here you can see from the timestamps that it is a different 
 buffer every iteration.  If the Ifile blocks are spread out all over the 
 disk, we might have to rewrite the entire segment table, one pass at a 
 time; so 10 iterations might be too few to merit a panic.  Please try 
 this patch instead (also attached):
 
 Index: sys/ufs/lfs/lfs_accessors.h
 ===================================================================
 RCS file: /cvsroot/src/sys/ufs/lfs/lfs_accessors.h,v
 retrieving revision 1.58
 diff -u -r1.58 lfs_accessors.h
 --- sys/ufs/lfs/lfs_accessors.h 23 Sep 2026 17:47:52 -0000 1.58
 +++ sys/ufs/lfs/lfs_accessors.h 26 Sep 2026 00:21:45 -0000
 @@ -663,11 +663,15 @@
   #ifdef _KERNEL
   # define SHARE_IFLOCK(F)        \
     do {        \
 -       rw_enter(&(F)->lfs_iflock, RW_READER);               \
 +       if (!rw_write_held(&(F)->lfs_iflock)) {                \
 +               rw_enter(&(F)->lfs_iflock, RW_READER);               \
 +       }        \
     } while(0)
   # define UNSHARE_IFLOCK(F)        \
     do {        \
 -       rw_exit(&(F)->lfs_iflock);               \
 +       if (!rw_write_held(&(F)->lfs_iflock)) {                \
 +               rw_exit(&(F)->lfs_iflock);               \
 +       }        \
     } while(0)
   #else /* ! _KERNEL */
   # define SHARE_IFLOCK(F)
 @@ -689,17 +693,18 @@
                          ((IN) & (lfs_sb_getsepb(F) - 1)));             \
          else         \
                  (SP) = (SEGUSE *)(BP)->b_data + ((IN) % 
 lfs_sb_getsepb(F)); \
 -       UNSHARE_IFLOCK(F);         \
   } while (0)
 
   #define LFS_WRITESEGENTRY(SP, F, IN, BP) do {         \
          if (((BP)->b_flags & B_GATHERED) == 0)               \
                  (F)->lfs_flags |= LFS_IFDIRTY;           \
          LFS_BWRITE_LOG(BP);        \
 +       UNSHARE_IFLOCK(F);         \
   } while (0)
 
   #define LFS_RELEASESEGENTRY(SP, F, IN, BP) do {                \
          brelse((BP), 0);         \
 +       UNSHARE_IFLOCK(F);         \
   } while (0)
 
   /*
 @@ -860,7 +865,6 @@
          lfs_sb_getbsize(F), 0, &(BP))) != 0)             \
                  panic("lfs: ifile ino %d read %d", (int)(IN), _e);      \
          LFS_IENTRY_INBLOCK(IP, F, IN, BP);         \
 -       UNSHARE_IFLOCK(F);         \
   } while (0)
   #define LFS_IENTRY_NEXT(IP, F) do { \
          if ((F)->lfs_is64) {           \
 @@ -875,9 +879,11 @@
          if (((BP)->b_flags & B_GATHERED) == 0)               \
                  (F)->lfs_flags |= LFS_IFDIRTY;           \
          LFS_BWRITE_LOG(BP);        \
 +       UNSHARE_IFLOCK(F);         \
   } while (0)
   #define LFS_RELEASEIENTRY(IP, F, IN, BP) do {         \
          brelse((BP), 0);         \
 +       UNSHARE_IFLOCK(F);         \
   } while (0)
 
   #define LFS_DEF_IF_ACCESSOR(type, type32, field) \
 Index: sys/ufs/lfs/lfs_segment.c
 ===================================================================
 RCS file: /cvsroot/src/sys/ufs/lfs/lfs_segment.c,v
 retrieving revision 1.315
 diff -u -r1.315 lfs_segment.c
 --- sys/ufs/lfs/lfs_segment.c   23 Sep 2026 17:47:52 -0000 1.315
 +++ sys/ufs/lfs/lfs_segment.c   26 Sep 2026 00:21:45 -0000
 @@ -1034,14 +1034,6 @@
                  mutex_enter(vp->v_interlock);
                  LIST_FOREACH(bp, &fs->lfs_ivnode->v_dirtyblkhd, b_vnbufs) {
                          if (!(bp->b_flags & B_GATHERED)) {
 -                               DLOG((DLOG_SU, "ifile dirty lbn 0x%lx"
 -                                       " flags 0x%x"
 -                                       " cflags 0x%x"
 -                                       " oflags 0x%x\n",
 -                                       (long)bp->b_lblkno,
 -                                       bp->b_flags,
 -                                       bp->b_cflags,
 -                                       bp->b_oflags));
                                  redo = 1;
                                  break;
                          }
 @@ -1058,24 +1050,30 @@
                          lfs_sb_setidaddr(fs, 0x0);
                  }
                  ++count;
 -               if (count > 2) {
 -                       /*
 -                        * XXX This is a kludge.  We are waiting on a
 -                        * busy buffer.  We need to wait for whoever
 -                        * has it to unbusy it; maybe for it to be
 -                        * read from disk.  A one clock tick wait
 -                        * should suffice.  Better would be to protect
 -                        * Ifile reads with the segment lock, but the
 -                        * segment lock would require some
 -                        * modification to work well for that.
 -                        */
 -                       kpause("lfsinow", false, 1, NULL);
 +               /*
 +                * We might need to gather another block for each
 +                * of the Ifile's segment blocks, if each of the
 +                * Ifile blocks we're overwriting was in a different
 +                * segment before.  More than segtabsz retries, though,
 +                * and we likely will never finish.
 +                */
 +               if (count > lfs_sb_getsegtabsz(fs)) {
   #ifdef DEBUG
 -                       log(LOG_NOTICE, "lfs_writeinode: looping 
 count=%d\n", count);
 +                       LIST_FOREACH(bp, &fs->lfs_ivnode->v_dirtyblkhd, 
 b_vnbufs) {
 +                               if (!(bp->b_flags & B_GATHERED)) {
 +                                       printf("ifile dirty lbn 0x%lx"
 +                                               " flags 0x%x"
 +                                               " cflags 0x%x"
 +                                               " oflags 0x%x\n",
 +  (long)bp->b_lblkno,
 +                                               bp->b_flags,
 +                                               bp->b_cflags,
 +  bp->b_oflags);
 +                               }
 +                       }
   #endif /* DEBUG */
 -               }
 -               if (count > 10)
                          panic("lfs_writeinode: looping");
 +               }
                  /* Write the file again, to gather the blocks */
                  lfs_writefile(fs, sp, fs->lfs_ivnode);
          }
 Index: sys/ufs/lfs/lfs_subr.c
 ===================================================================
 RCS file: /cvsroot/src/sys/ufs/lfs/lfs_subr.c,v
 retrieving revision 1.111
 diff -u -r1.111 lfs_subr.c
 --- sys/ufs/lfs/lfs_subr.c      23 Sep 2026 17:47:52 -0000 1.111
 +++ sys/ufs/lfs/lfs_subr.c      26 Sep 2026 00:21:45 -0000
 @@ -688,6 +688,8 @@
          /* Acquire lock */
          fs->lfs_prelock = 1;
          fs->lfs_prelocklwp = curlwp;
 +
 +       rw_enter(&fs->lfs_iflock, RW_WRITER);
    out:
          mutex_exit(&lfs_lock);
 
 @@ -719,6 +721,8 @@
          if (--fs->lfs_prelock == 0) {
                  fs->lfs_prelocklwp = NULL;
                  cv_broadcast(&fs->lfs_prelockcv);
 +
 +               rw_exit(&fs->lfs_iflock);
          }
          mutex_exit(&lfs_lock);
   }
 Index: sys/ufs/lfs/lfs_vfsops.c
 ===================================================================
 RCS file: /cvsroot/src/sys/ufs/lfs/lfs_vfsops.c,v
 retrieving revision 1.406
 diff -u -r1.406 lfs_vfsops.c
 --- sys/ufs/lfs/lfs_vfsops.c    24 Sep 2026 00:08:46 -0000 1.406
 +++ sys/ufs/lfs/lfs_vfsops.c    26 Sep 2026 00:21:45 -0000
 @@ -2597,7 +2597,6 @@
           * is holding Ifile buffers, so we get each one, to drain them.
           * (XXX this could be done better.)
           */
 -       rw_enter(&fs->lfs_iflock, RW_WRITER);
          for (i = 0; i < ilast; i++) {
                  /* XXX what to do if bread fails? */
                  bread(ivp, i, lfs_sb_getbsize(fs), 0, &bp);
 @@ -2721,9 +2720,6 @@
          lfs_ci_setdirty(fs, cip, lfs_sb_getnseg(fs) - 
 lfs_sb_getnclean(fs));
          VOP_BWRITE(bp->b_vp, bp);
 
 -       /* Let Ifile accesses proceed */
 -       rw_exit(&fs->lfs_iflock);
 -
       out:
          lfs_segunlock(fs);
          return error;
 
 Thanks,
 
 --
 Konrad Schroder
 perseant%hhhh.org@localhost
 
 --------------dxiTaDNF4uWZ14qRRrTgAVFn
 Content-Type: text/plain; charset=UTF-8; name="60746g.diff"
 Content-Disposition: attachment; filename="60746g.diff"
 Content-Transfer-Encoding: base64
 
 SW5kZXg6IHN5cy91ZnMvbGZzL2xmc19hY2Nlc3NvcnMuaAo9PT09PT09PT09PT09PT09PT09
 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09ClJDUyBm
 aWxlOiAvY3Zzcm9vdC9zcmMvc3lzL3Vmcy9sZnMvbGZzX2FjY2Vzc29ycy5oLHYKcmV0cmll
 dmluZyByZXZpc2lvbiAxLjU4CmRpZmYgLXUgLXIxLjU4IGxmc19hY2Nlc3NvcnMuaAotLS0g
 c3lzL3Vmcy9sZnMvbGZzX2FjY2Vzc29ycy5oCTIzIFNlcCAyMDI2IDE3OjQ3OjUyIC0wMDAw
 CTEuNTgKKysrIHN5cy91ZnMvbGZzL2xmc19hY2Nlc3NvcnMuaAkyNiBTZXAgMjAyNiAwMDoy
 MTo0NSAtMDAwMApAQCAtNjYzLDExICs2NjMsMTUgQEAKICNpZmRlZiBfS0VSTkVMCiAjIGRl
 ZmluZSBTSEFSRV9JRkxPQ0soRikgCQkJCQkJXAogICBkbyB7CQkJCQkJCQkJXAotCXJ3X2Vu
 dGVyKCYoRiktPmxmc19pZmxvY2ssIFJXX1JFQURFUik7CQkJCVwKKwlpZiAoIXJ3X3dyaXRl
 X2hlbGQoJihGKS0+bGZzX2lmbG9jaykpIHsJCQkJXAorCQlyd19lbnRlcigmKEYpLT5sZnNf
 aWZsb2NrLCBSV19SRUFERVIpOwkJCVwKKwl9CQkJCQkJCQlcCiAgIH0gd2hpbGUoMCkKICMg
 ZGVmaW5lIFVOU0hBUkVfSUZMT0NLKEYpCQkJCQkJXAogICBkbyB7CQkJCQkJCQkJXAotCXJ3
 X2V4aXQoJihGKS0+bGZzX2lmbG9jayk7CQkJCQlcCisJaWYgKCFyd193cml0ZV9oZWxkKCYo
 RiktPmxmc19pZmxvY2spKSB7CQkJCVwKKwkJcndfZXhpdCgmKEYpLT5sZnNfaWZsb2NrKTsJ
 CQkJXAorCX0JCQkJCQkJCVwKICAgfSB3aGlsZSgwKQogI2Vsc2UgLyogISBfS0VSTkVMICov
 CiAjIGRlZmluZSBTSEFSRV9JRkxPQ0soRikKQEAgLTY4OSwxNyArNjkzLDE4IEBACiAJCQko
 KElOKSAmIChsZnNfc2JfZ2V0c2VwYihGKSAtIDEpKSk7CQlcCiAJZWxzZQkJCQkJCQkJXAog
 CQkoU1ApID0gKFNFR1VTRSAqKShCUCktPmJfZGF0YSArICgoSU4pICUgbGZzX3NiX2dldHNl
 cGIoRikpOyBcCi0JVU5TSEFSRV9JRkxPQ0soRik7CQkJCQkJXAogfSB3aGlsZSAoMCkKIAog
 I2RlZmluZSBMRlNfV1JJVEVTRUdFTlRSWShTUCwgRiwgSU4sIEJQKSBkbyB7CQkJCVwKIAlp
 ZiAoKChCUCktPmJfZmxhZ3MgJiBCX0dBVEhFUkVEKSA9PSAwKQkJCSAJXAogCQkoRiktPmxm
 c19mbGFncyB8PSBMRlNfSUZESVJUWTsJCQkJXAogCUxGU19CV1JJVEVfTE9HKEJQKTsJCQkJ
 CQlcCisJVU5TSEFSRV9JRkxPQ0soRik7CQkJCQkJXAogfSB3aGlsZSAoMCkKIAogI2RlZmlu
 ZSBMRlNfUkVMRUFTRVNFR0VOVFJZKFNQLCBGLCBJTiwgQlApIGRvIHsJCQkJXAogCWJyZWxz
 ZSgoQlApLCAwKTsJCQkJCQlcCisJVU5TSEFSRV9JRkxPQ0soRik7CQkJCQkJXAogfSB3aGls
 ZSAoMCkKIAogLyoKQEAgLTg2MCw3ICs4NjUsNiBAQAogCWxmc19zYl9nZXRic2l6ZShGKSwg
 MCwgJihCUCkpKSAhPSAwKQkJCQlcCiAJCXBhbmljKCJsZnM6IGlmaWxlIGlubyAlZCByZWFk
 ICVkIiwgKGludCkoSU4pLCBfZSk7CVwKIAlMRlNfSUVOVFJZX0lOQkxPQ0soSVAsIEYsIElO
 LCBCUCk7CQkJCVwKLQlVTlNIQVJFX0lGTE9DSyhGKTsJCQkJCQlcCiB9IHdoaWxlICgwKQog
 I2RlZmluZSBMRlNfSUVOVFJZX05FWFQoSVAsIEYpIGRvIHsgXAogCWlmICgoRiktPmxmc19p
 czY0KSB7CQkJCQkJXApAQCAtODc1LDkgKzg3OSwxMSBAQAogCWlmICgoKEJQKS0+Yl9mbGFn
 cyAmIEJfR0FUSEVSRUQpID09IDApCQkJCVwKIAkJKEYpLT5sZnNfZmxhZ3MgfD0gTEZTX0lG
 RElSVFk7CQkJCVwKIAlMRlNfQldSSVRFX0xPRyhCUCk7CQkJCQkJXAorCVVOU0hBUkVfSUZM
 T0NLKEYpOwkJCQkJCVwKIH0gd2hpbGUgKDApCiAjZGVmaW5lIExGU19SRUxFQVNFSUVOVFJZ
 KElQLCBGLCBJTiwgQlApIGRvIHsJCQkJXAogCWJyZWxzZSgoQlApLCAwKTsJCQkJCQlcCisJ
 VU5TSEFSRV9JRkxPQ0soRik7CQkJCQkJXAogfSB3aGlsZSAoMCkKIAogI2RlZmluZSBMRlNf
 REVGX0lGX0FDQ0VTU09SKHR5cGUsIHR5cGUzMiwgZmllbGQpIFwKSW5kZXg6IHN5cy91ZnMv
 bGZzL2xmc19zZWdtZW50LmMKPT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09
 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PQpSQ1MgZmlsZTogL2N2c3Jvb3Qvc3Jj
 L3N5cy91ZnMvbGZzL2xmc19zZWdtZW50LmMsdgpyZXRyaWV2aW5nIHJldmlzaW9uIDEuMzE1
 CmRpZmYgLXUgLXIxLjMxNSBsZnNfc2VnbWVudC5jCi0tLSBzeXMvdWZzL2xmcy9sZnNfc2Vn
 bWVudC5jCTIzIFNlcCAyMDI2IDE3OjQ3OjUyIC0wMDAwCTEuMzE1CisrKyBzeXMvdWZzL2xm
 cy9sZnNfc2VnbWVudC5jCTI2IFNlcCAyMDI2IDAwOjIxOjQ1IC0wMDAwCkBAIC0xMDM0LDE0
 ICsxMDM0LDYgQEAKIAkJbXV0ZXhfZW50ZXIodnAtPnZfaW50ZXJsb2NrKTsKIAkJTElTVF9G
 T1JFQUNIKGJwLCAmZnMtPmxmc19pdm5vZGUtPnZfZGlydHlibGtoZCwgYl92bmJ1ZnMpIHsK
 IAkJCWlmICghKGJwLT5iX2ZsYWdzICYgQl9HQVRIRVJFRCkpIHsKLQkJCQlETE9HKChETE9H
 X1NVLCAiaWZpbGUgZGlydHkgbGJuIDB4JWx4IgotCQkJCQkiIGZsYWdzIDB4JXgiCi0JCQkJ
 CSIgY2ZsYWdzIDB4JXgiCi0JCQkJCSIgb2ZsYWdzIDB4JXhcbiIsCi0JCQkJCShsb25nKWJw
 LT5iX2xibGtubywKLQkJCQkJYnAtPmJfZmxhZ3MsCi0JCQkJCWJwLT5iX2NmbGFncywKLQkJ
 CQkJYnAtPmJfb2ZsYWdzKSk7CiAJCQkJcmVkbyA9IDE7CiAJCQkJYnJlYWs7CiAJCQl9CkBA
 IC0xMDU4LDI0ICsxMDUwLDMwIEBACiAJCQlsZnNfc2Jfc2V0aWRhZGRyKGZzLCAweDApOwog
 CQl9CiAJCSsrY291bnQ7Ci0JCWlmIChjb3VudCA+IDIpIHsKLQkJCS8qCi0JCQkgKiBYWFgg
 VGhpcyBpcyBhIGtsdWRnZS4gIFdlIGFyZSB3YWl0aW5nIG9uIGEKLQkJCSAqIGJ1c3kgYnVm
 ZmVyLiAgV2UgbmVlZCB0byB3YWl0IGZvciB3aG9ldmVyCi0JCQkgKiBoYXMgaXQgdG8gdW5i
 dXN5IGl0OyBtYXliZSBmb3IgaXQgdG8gYmUKLQkJCSAqIHJlYWQgZnJvbSBkaXNrLiAgQSBv
 bmUgY2xvY2sgdGljayB3YWl0Ci0JCQkgKiBzaG91bGQgc3VmZmljZS4gIEJldHRlciB3b3Vs
 ZCBiZSB0byBwcm90ZWN0Ci0JCQkgKiBJZmlsZSByZWFkcyB3aXRoIHRoZSBzZWdtZW50IGxv
 Y2ssIGJ1dCB0aGUKLQkJCSAqIHNlZ21lbnQgbG9jayB3b3VsZCByZXF1aXJlIHNvbWUKLQkJ
 CSAqIG1vZGlmaWNhdGlvbiB0byB3b3JrIHdlbGwgZm9yIHRoYXQuCi0JCQkgKi8KLQkJCWtw
 YXVzZSgibGZzaW5vdyIsIGZhbHNlLCAxLCBOVUxMKTsKKwkJLyoKKwkJICogV2UgbWlnaHQg
 bmVlZCB0byBnYXRoZXIgYW5vdGhlciBibG9jayBmb3IgZWFjaAorCQkgKiBvZiB0aGUgSWZp
 bGUncyBzZWdtZW50IGJsb2NrcywgaWYgZWFjaCBvZiB0aGUKKwkJICogSWZpbGUgYmxvY2tz
 IHdlJ3JlIG92ZXJ3cml0aW5nIHdhcyBpbiBhIGRpZmZlcmVudAorCQkgKiBzZWdtZW50IGJl
 Zm9yZS4gIE1vcmUgdGhhbiBzZWd0YWJzeiByZXRyaWVzLCB0aG91Z2gsCisJCSAqIGFuZCB3
 ZSBsaWtlbHkgd2lsbCBuZXZlciBmaW5pc2guCisJCSAqLworCQlpZiAoY291bnQgPiBsZnNf
 c2JfZ2V0c2VndGFic3ooZnMpKSB7CiAjaWZkZWYgREVCVUcKLQkJCWxvZyhMT0dfTk9USUNF
 LCAibGZzX3dyaXRlaW5vZGU6IGxvb3BpbmcgY291bnQ9JWRcbiIsIGNvdW50KTsKKwkJCUxJ
 U1RfRk9SRUFDSChicCwgJmZzLT5sZnNfaXZub2RlLT52X2RpcnR5YmxraGQsIGJfdm5idWZz
 KSB7CisJCQkJaWYgKCEoYnAtPmJfZmxhZ3MgJiBCX0dBVEhFUkVEKSkgeworCQkJCQlwcmlu
 dGYoImlmaWxlIGRpcnR5IGxibiAweCVseCIKKwkJCQkJCSIgZmxhZ3MgMHgleCIKKwkJCQkJ
 CSIgY2ZsYWdzIDB4JXgiCisJCQkJCQkiIG9mbGFncyAweCV4XG4iLAorCQkJCQkJKGxvbmcp
 YnAtPmJfbGJsa25vLAorCQkJCQkJYnAtPmJfZmxhZ3MsCisJCQkJCQlicC0+Yl9jZmxhZ3Ms
 CisJCQkJCQlicC0+Yl9vZmxhZ3MpOworCQkJCX0KKwkJCX0KICNlbmRpZiAvKiBERUJVRyAq
 LwotCQl9Ci0JCWlmIChjb3VudCA+IDEwKQogCQkJcGFuaWMoImxmc193cml0ZWlub2RlOiBs
 b29waW5nIik7CisJCX0KIAkJLyogV3JpdGUgdGhlIGZpbGUgYWdhaW4sIHRvIGdhdGhlciB0
 aGUgYmxvY2tzICovCiAJCWxmc193cml0ZWZpbGUoZnMsIHNwLCBmcy0+bGZzX2l2bm9kZSk7
 CiAJfQpJbmRleDogc3lzL3Vmcy9sZnMvbGZzX3N1YnIuYwo9PT09PT09PT09PT09PT09PT09
 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09ClJDUyBm
 aWxlOiAvY3Zzcm9vdC9zcmMvc3lzL3Vmcy9sZnMvbGZzX3N1YnIuYyx2CnJldHJpZXZpbmcg
 cmV2aXNpb24gMS4xMTEKZGlmZiAtdSAtcjEuMTExIGxmc19zdWJyLmMKLS0tIHN5cy91ZnMv
 bGZzL2xmc19zdWJyLmMJMjMgU2VwIDIwMjYgMTc6NDc6NTIgLTAwMDAJMS4xMTEKKysrIHN5
 cy91ZnMvbGZzL2xmc19zdWJyLmMJMjYgU2VwIDIwMjYgMDA6MjE6NDUgLTAwMDAKQEAgLTY4
 OCw2ICs2ODgsOCBAQAogCS8qIEFjcXVpcmUgbG9jayAqLwogCWZzLT5sZnNfcHJlbG9jayA9
 IDE7CiAJZnMtPmxmc19wcmVsb2NrbHdwID0gY3VybHdwOworCisJcndfZW50ZXIoJmZzLT5s
 ZnNfaWZsb2NrLCBSV19XUklURVIpOwogIG91dDoKIAltdXRleF9leGl0KCZsZnNfbG9jayk7
 CiAKQEAgLTcxOSw2ICs3MjEsOCBAQAogCWlmICgtLWZzLT5sZnNfcHJlbG9jayA9PSAwKSB7
 CiAJCWZzLT5sZnNfcHJlbG9ja2x3cCA9IE5VTEw7CiAJCWN2X2Jyb2FkY2FzdCgmZnMtPmxm
 c19wcmVsb2NrY3YpOworCisJCXJ3X2V4aXQoJmZzLT5sZnNfaWZsb2NrKTsKIAl9CiAJbXV0
 ZXhfZXhpdCgmbGZzX2xvY2spOwogfQpJbmRleDogc3lzL3Vmcy9sZnMvbGZzX3Zmc29wcy5j
 Cj09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09
 PT09PT09PT09PT09PT0KUkNTIGZpbGU6IC9jdnNyb290L3NyYy9zeXMvdWZzL2xmcy9sZnNf
 dmZzb3BzLmMsdgpyZXRyaWV2aW5nIHJldmlzaW9uIDEuNDA2CmRpZmYgLXUgLXIxLjQwNiBs
 ZnNfdmZzb3BzLmMKLS0tIHN5cy91ZnMvbGZzL2xmc192ZnNvcHMuYwkyNCBTZXAgMjAyNiAw
 MDowODo0NiAtMDAwMAkxLjQwNgorKysgc3lzL3Vmcy9sZnMvbGZzX3Zmc29wcy5jCTI2IFNl
 cCAyMDI2IDAwOjIxOjQ1IC0wMDAwCkBAIC0yNTk3LDcgKzI1OTcsNiBAQAogCSAqIGlzIGhv
 bGRpbmcgSWZpbGUgYnVmZmVycywgc28gd2UgZ2V0IGVhY2ggb25lLCB0byBkcmFpbiB0aGVt
 LgogCSAqIChYWFggdGhpcyBjb3VsZCBiZSBkb25lIGJldHRlci4pCiAJICovCi0JcndfZW50
 ZXIoJmZzLT5sZnNfaWZsb2NrLCBSV19XUklURVIpOwogCWZvciAoaSA9IDA7IGkgPCBpbGFz
 dDsgaSsrKSB7CiAJCS8qIFhYWCB3aGF0IHRvIGRvIGlmIGJyZWFkIGZhaWxzPyAqLwogCQli
 cmVhZChpdnAsIGksIGxmc19zYl9nZXRic2l6ZShmcyksIDAsICZicCk7CkBAIC0yNzIxLDkg
 KzI3MjAsNiBAQAogCWxmc19jaV9zZXRkaXJ0eShmcywgY2lwLCBsZnNfc2JfZ2V0bnNlZyhm
 cykgLSBsZnNfc2JfZ2V0bmNsZWFuKGZzKSk7CiAJVk9QX0JXUklURShicC0+Yl92cCwgYnAp
 OwogCi0JLyogTGV0IElmaWxlIGFjY2Vzc2VzIHByb2NlZWQgKi8KLQlyd19leGl0KCZmcy0+
 bGZzX2lmbG9jayk7Ci0KICAgICBvdXQ6CiAJbGZzX3NlZ3VubG9jayhmcyk7CiAJcmV0dXJu
 IGVycm9yOwo=
 
 --------------dxiTaDNF4uWZ14qRRrTgAVFn--
Home | Main Index | Thread Index | Old Index