xv6 system panic when attempt to read big file

Question

This is the old task of implementing double-indirect inodes for the xv6 system. In double indirect a file can have 16523 blocks (11 direct-pointer + 1 single-indirect-pointer*128 + 1 double-indirect-pointer*128*128), and my implementation satisfies this condition according to the usertests output (I will present it below).

The full code of the xv6 system can be found at https://github.com/mit-pdos/xv6-public, and since if you are here you probably familiar with it, I will only present the modifications I made in the implementation of bmap() and itrunc() methods at fs.c:

// NINDIRECT is 128
// NDIRECT is 11
// There is one less direct pointer to make room for the double-indirect

// Return the disk block address of the nth block in inode ip.
// If there is no such block, bmap allocates one.
static uint
bmap(struct inode *ip, uint bn)
{
  uint addr, *a;
  uint *indirect;
  struct buf *bp;
  struct buf *dbp;

  // Direct Pointer
  if(bn < NDIRECT){
    // get direct pointer, allocate if necessary
    if((addr = ip->addrs[bn]) == 0)
      ip->addrs[bn] = addr = balloc(ip->dev);
    return addr;
  }
  bn -= NDIRECT;

  // Indirect Pointer
  if(bn < NINDIRECT){
    // load indirect block, allocate if necessary
    if((addr = ip->addrs[NDIRECT]) == 0)
      ip->addrs[NDIRECT] = addr = balloc(ip->dev);
    bp = bread(ip->dev, addr);
    a = (uint*)bp->data;
    // get direct pointer, allocate if necessary
    if((addr = a[bn]) == 0){
      a[bn] = addr = balloc(ip->dev);
      log_write(bp);
    }
    // release indirect block
    brelse(bp);
    // return disk block address
    return addr;
  }
  bn -= NINDIRECT;

  // Double-indirect Pointer
  if(bn < NDINDIRECT){
    // load double-indirect block, allocate if necessary
    if((addr = ip->addrs[NDIRECT+1]) == 0)
      ip->addrs[NDIRECT] = addr = balloc(ip->dev);
    dbp = bread(ip->dev,addr);
    indirect = (uint*)dbp->data;
    // load indirect block, allocate if necessary
    if((addr = indirect[bn/NINDIRECT]) == 0)
      indirect[bn/NINDIRECT] = addr = balloc(ip->dev);
    bp = bread(ip->dev,addr);
    a = (uint*)bp->data;
    // get direct pointer, allocate if necessary
    if((addr = a[bn%NINDIRECT]) == 0){
      a[bn%NINDIRECT] = addr = balloc(ip->dev);
      log_write(bp);
    }
    // release indirect & double-indirect blocks
    brelse(bp);
    brelse(dbp);
    // return disk block address
    return addr;
  }

  panic("bmap: out of range");
}

// Truncate inode (discard contents).
// Only called when the inode has no links
// to it (no directory entries referring to it)
// and has no in-memory reference to it (is
// not an open file or current directory).
static void
itrunc(struct inode *ip)
{
  int i, j, k;
  struct buf *bp;
  struct buf *dbp;
  uint *a;
  uint *d;

  // free the direct pointers
  for(i = 0; i < NDIRECT; i++){
    if(ip->addrs[i]){
      bfree(ip->dev, ip->addrs[i]);
      ip->addrs[i] = 0;
    }
  }

  // free the indirect pointer
  if(ip->addrs[NDIRECT]){
    // load the indirect block
    bp = bread(ip->dev, ip->addrs[NDIRECT]);
    a = (uint*)bp->data;
    // iterate over the block, and free all direct pointers
    for(j = 0; j < NINDIRECT; j++){
      if(a[j])
        bfree(ip->dev, a[j]);
    }
    // free the indirect pointer
    brelse(bp);
    bfree(ip->dev, ip->addrs[NDIRECT]);
    ip->addrs[NDIRECT] = 0;
  }

  // free the double indirect pointer
  if(ip->addrs[NDIRECT+1]){
    // load the double-indirect block
    dbp = bread(ip->dev, ip->addrs[NDIRECT+1]);
    d = (uint*)dbp->data;
    // iterate over the block, and free all indirect blocks
    for(k = 0; k < NINDIRECT; k++){
      // load the indirect block
      bp = bread(ip->dev, d[k]);
      a = (uint*)bp->data;
      // iterate over the block, and free all direct pointers
      for(j = 0; j < NINDIRECT; j++){
        if(a[j])
          bfree(ip->dev,a[j]);
      }
      // free the infirect pointer
      brelse(bp);
      bfree(ip->dev, d[k]);
      d[k] = 0;
    }
    // free the double-indirect pointer
    brelse(dbp);
    bfree(ip->dev, ip->addrs[NDIRECT+1]);
    ip->addrs[NDIRECT+1] = 0;
  }

  ip->size = 0;
  iupdate(ip);
}

The output I get from the usertests utility shows that the writing part is successful, but the system panic when it attempt to read the big file:

wrote 16523 sectors
closed the file for writing
opend the file for reading
read 0 sectors
lapicid 1: panic: log_write outside of trans
 80102f18 80101249 80101442 80101b67 80100f89 80104b42 8010482a 80105829 80105572 0

I modified the bigfile() test a bit, so I will post it here too:

void
bigfile(void)
{
  char buf[512];
  int fd, i, sectors;
  unlink("big.file");
  fd = open("big.file", O_CREATE | O_WRONLY);
  if(fd < 0){
    printf(2, "big: cannot open big.file for writing\n");
    exit();
  }

  sectors = 0;
  while(1){
    *(int*)buf = sectors;
    int cc = write(fd, buf, sizeof(buf));
    if(cc <= 0)
      break;
    sectors++;
        if (sectors % 100 == 0){
                printf(2, ".");
                printf(2,"sector: %d\n",sectors);
        }
  }

  printf(1, "\nwrote %d sectors\n", sectors);

  close(fd);
  printf(1,"closed the file for writing\n");

  fd = open("big.file", O_RDONLY);
  if(fd < 0){
    printf(2, "big: cannot re-open big.file for reading\n");
    exit();
  }
  printf(1,"opend the file for reading\n");

  for(i = 0; i < sectors; i++){
    int cc = read(fd, buf, sizeof(buf));
    if(cc <= 0){
      printf(2, "big: read error at sector %d\n", i);
      exit();
    }
    if(*(int*)buf != i){
      printf(2, "big: read the wrong data (%d) for sector %d\n",
             *(int*)buf, i);
      exit();
    }
    if(i%100 == 0)
        printf(2,"read %d sectors\n",i);
  }

  close(fd);
  unlink("big.file");

  printf(1, "bigfile test ok\n");
}

Thanks in advance for any help. P.S: of course I modified the size of FSSIZE in the param.h file to be big enough for double indirect pointers.