[BACK]Return to xfs_lrw.c CVS log [TXT] [DIR] Up to [OSS] / xfs-linux / linux-2.6

Diff for /xfs-linux/linux-2.6/xfs_lrw.c between versions 1.269 and 1.270

version 1.269, 2007/09/21 04:08:28 version 1.270, 2007/09/21 16:10:12
Line 58 Line 58
 void  void
 xfs_rw_enter_trace(  xfs_rw_enter_trace(
         int                     tag,          int                     tag,
         xfs_iocore_t            *io,          xfs_inode_t             *ip,
         void                    *data,          void                    *data,
         size_t                  segs,          size_t                  segs,
         loff_t                  offset,          loff_t                  offset,
         int                     ioflags)          int                     ioflags)
 {  {
         xfs_inode_t     *ip = XFS_IO_INODE(io);  
   
         if (ip->i_rwtrace == NULL)          if (ip->i_rwtrace == NULL)
                 return;                  return;
         ktrace_enter(ip->i_rwtrace,          ktrace_enter(ip->i_rwtrace,
Line 78  xfs_rw_enter_trace( Line 76  xfs_rw_enter_trace(
                 (void *)((unsigned long)((offset >> 32) & 0xffffffff)),                  (void *)((unsigned long)((offset >> 32) & 0xffffffff)),
                 (void *)((unsigned long)(offset & 0xffffffff)),                  (void *)((unsigned long)(offset & 0xffffffff)),
                 (void *)((unsigned long)ioflags),                  (void *)((unsigned long)ioflags),
                 (void *)((unsigned long)((io->io_new_size >> 32) & 0xffffffff)),                  (void *)((unsigned long)((ip->i_new_size >> 32) & 0xffffffff)),
                 (void *)((unsigned long)(io->io_new_size & 0xffffffff)),                  (void *)((unsigned long)(ip->i_new_size & 0xffffffff)),
                 (void *)((unsigned long)current_pid()),                  (void *)((unsigned long)current_pid()),
                 (void *)NULL,                  (void *)NULL,
                 (void *)NULL,                  (void *)NULL,
Line 89  xfs_rw_enter_trace( Line 87  xfs_rw_enter_trace(
   
 void  void
 xfs_inval_cached_trace(  xfs_inval_cached_trace(
         xfs_iocore_t    *io,          xfs_inode_t     *ip,
         xfs_off_t       offset,          xfs_off_t       offset,
         xfs_off_t       len,          xfs_off_t       len,
         xfs_off_t       first,          xfs_off_t       first,
         xfs_off_t       last)          xfs_off_t       last)
 {  {
         xfs_inode_t     *ip = XFS_IO_INODE(io);  
   
         if (ip->i_rwtrace == NULL)          if (ip->i_rwtrace == NULL)
                 return;                  return;
Line 267  xfs_read( Line 264  xfs_read(
                 }                  }
         }          }
   
         xfs_rw_enter_trace(XFS_READ_ENTER, &ip->i_iocore,          xfs_rw_enter_trace(XFS_READ_ENTER, ip,
                                 (void *)iovp, segs, *offset, ioflags);                                  (void *)iovp, segs, *offset, ioflags);
   
         iocb->ki_pos = *offset;          iocb->ki_pos = *offset;
Line 312  xfs_splice_read( Line 309  xfs_splice_read(
                         return -error;                          return -error;
                 }                  }
         }          }
         xfs_rw_enter_trace(XFS_SPLICE_READ_ENTER, &ip->i_iocore,          xfs_rw_enter_trace(XFS_SPLICE_READ_ENTER, ip,
                            pipe, count, *ppos, ioflags);                             pipe, count, *ppos, ioflags);
         ret = generic_file_splice_read(infilp, ppos, pipe, count, flags);          ret = generic_file_splice_read(infilp, ppos, pipe, count, flags);
         if (ret > 0)          if (ret > 0)
Line 334  xfs_splice_write( Line 331  xfs_splice_write(
 {  {
         bhv_vnode_t             *vp = XFS_ITOV(ip);          bhv_vnode_t             *vp = XFS_ITOV(ip);
         xfs_mount_t             *mp = ip->i_mount;          xfs_mount_t             *mp = ip->i_mount;
         xfs_iocore_t            *io = &ip->i_iocore;  
         ssize_t                 ret;          ssize_t                 ret;
         struct inode            *inode = outfilp->f_mapping->host;          struct inode            *inode = outfilp->f_mapping->host;
         xfs_fsize_t             isize, new_size;          xfs_fsize_t             isize, new_size;
Line 361  xfs_splice_write( Line 357  xfs_splice_write(
   
         xfs_ilock(ip, XFS_ILOCK_EXCL);          xfs_ilock(ip, XFS_ILOCK_EXCL);
         if (new_size > ip->i_size)          if (new_size > ip->i_size)
                 io->io_new_size = new_size;                  ip->i_new_size = new_size;
         xfs_iunlock(ip, XFS_ILOCK_EXCL);          xfs_iunlock(ip, XFS_ILOCK_EXCL);
   
         xfs_rw_enter_trace(XFS_SPLICE_WRITE_ENTER, &ip->i_iocore,          xfs_rw_enter_trace(XFS_SPLICE_WRITE_ENTER, ip,
                            pipe, count, *ppos, ioflags);                             pipe, count, *ppos, ioflags);
         ret = generic_file_splice_write(pipe, outfilp, ppos, count, flags);          ret = generic_file_splice_write(pipe, outfilp, ppos, count, flags);
         if (ret > 0)          if (ret > 0)
Line 381  xfs_splice_write( Line 377  xfs_splice_write(
                 xfs_iunlock(ip, XFS_ILOCK_EXCL);                  xfs_iunlock(ip, XFS_ILOCK_EXCL);
         }          }
   
         if (io->io_new_size) {          if (ip->i_new_size) {
                 xfs_ilock(ip, XFS_ILOCK_EXCL);                  xfs_ilock(ip, XFS_ILOCK_EXCL);
                 io->io_new_size = 0;                  ip->i_new_size = 0;
                 if (ip->i_d.di_size > ip->i_size)                  if (ip->i_d.di_size > ip->i_size)
                         ip->i_d.di_size = ip->i_size;                          ip->i_d.di_size = ip->i_size;
                 xfs_iunlock(ip, XFS_ILOCK_EXCL);                  xfs_iunlock(ip, XFS_ILOCK_EXCL);
Line 472  xfs_zero_eof( Line 468  xfs_zero_eof(
         xfs_off_t       offset,         /* starting I/O offset */          xfs_off_t       offset,         /* starting I/O offset */
         xfs_fsize_t     isize)          /* current inode size */          xfs_fsize_t     isize)          /* current inode size */
 {  {
         xfs_iocore_t    *io = &ip->i_iocore;          xfs_mount_t     *mp = ip->i_mount;
         xfs_fileoff_t   start_zero_fsb;          xfs_fileoff_t   start_zero_fsb;
         xfs_fileoff_t   end_zero_fsb;          xfs_fileoff_t   end_zero_fsb;
         xfs_fileoff_t   zero_count_fsb;          xfs_fileoff_t   zero_count_fsb;
         xfs_fileoff_t   last_fsb;          xfs_fileoff_t   last_fsb;
         xfs_fileoff_t   zero_off;          xfs_fileoff_t   zero_off;
         xfs_fsize_t     zero_len;          xfs_fsize_t     zero_len;
         xfs_mount_t     *mp = io->io_mount;  
         int             nimaps;          int             nimaps;
         int             error = 0;          int             error = 0;
         xfs_bmbt_irec_t imap;          xfs_bmbt_irec_t imap;
   
         ASSERT(ismrlocked(io->io_lock, MR_UPDATE));          ASSERT(ismrlocked(&ip->i_lock, MR_UPDATE));
         ASSERT(ismrlocked(io->io_iolock, MR_UPDATE));          ASSERT(ismrlocked(&ip->i_iolock, MR_UPDATE));
         ASSERT(offset > isize);          ASSERT(offset > isize);
   
         /*          /*
Line 494  xfs_zero_eof( Line 489  xfs_zero_eof(
          */           */
         error = xfs_zero_last_block(ip, offset, isize);          error = xfs_zero_last_block(ip, offset, isize);
         if (error) {          if (error) {
                 ASSERT(ismrlocked(io->io_lock, MR_UPDATE));                  ASSERT(ismrlocked(&ip->i_lock, MR_UPDATE));
                 ASSERT(ismrlocked(io->io_iolock, MR_UPDATE));                  ASSERT(ismrlocked(&ip->i_iolock, MR_UPDATE));
                 return error;                  return error;
         }          }
   
Line 526  xfs_zero_eof( Line 521  xfs_zero_eof(
                 error = xfs_bmapi(NULL, ip, start_zero_fsb, zero_count_fsb,                  error = xfs_bmapi(NULL, ip, start_zero_fsb, zero_count_fsb,
                                   0, NULL, 0, &imap, &nimaps, NULL, NULL);                                    0, NULL, 0, &imap, &nimaps, NULL, NULL);
                 if (error) {                  if (error) {
                         ASSERT(ismrlocked(io->io_lock, MR_UPDATE));                          ASSERT(ismrlocked(&ip->i_lock, MR_UPDATE));
                         ASSERT(ismrlocked(io->io_iolock, MR_UPDATE));                          ASSERT(ismrlocked(&ip->i_iolock, MR_UPDATE));
                         return error;                          return error;
                 }                  }
                 ASSERT(nimaps > 0);                  ASSERT(nimaps > 0);
Line 595  xfs_write( Line 590  xfs_write(
         xfs_mount_t             *mp;          xfs_mount_t             *mp;
         ssize_t                 ret = 0, error = 0;          ssize_t                 ret = 0, error = 0;
         xfs_fsize_t             isize, new_size;          xfs_fsize_t             isize, new_size;
         xfs_iocore_t            *io;  
         int                     iolock;          int                     iolock;
         int                     eventsent = 0;          int                     eventsent = 0;
         bhv_vrwlock_t           locktype;          bhv_vrwlock_t           locktype;
Line 615  xfs_write( Line 609  xfs_write(
         if (count == 0)          if (count == 0)
                 return 0;                  return 0;
   
         io = &xip->i_iocore;          mp = xip->i_mount;
         mp = io->io_mount;  
   
         xfs_wait_for_freeze(mp, SB_FREEZE_WRITE);          xfs_wait_for_freeze(mp, SB_FREEZE_WRITE);
   
Line 696  start: Line 689  start:
   
         new_size = pos + count;          new_size = pos + count;
         if (new_size > xip->i_size)          if (new_size > xip->i_size)
                 io->io_new_size = new_size;                  xip->i_new_size = new_size;
   
         if (likely(!(ioflags & IO_INVIS))) {          if (likely(!(ioflags & IO_INVIS))) {
                 file_update_time(file);                  file_update_time(file);
Line 748  retry: Line 741  retry:
         if ((ioflags & IO_ISDIRECT)) {          if ((ioflags & IO_ISDIRECT)) {
                 if (VN_CACHED(vp)) {                  if (VN_CACHED(vp)) {
                         WARN_ON(need_i_mutex == 0);                          WARN_ON(need_i_mutex == 0);
                         xfs_inval_cached_trace(io, pos, -1,                          xfs_inval_cached_trace(xip, pos, -1,
                                         ctooff(offtoct(pos)), -1);                                          ctooff(offtoct(pos)), -1);
                         error = xfs_flushinval_pages(xip,                          error = xfs_flushinval_pages(xip,
                                         ctooff(offtoct(pos)),                                          ctooff(offtoct(pos)),
Line 767  retry: Line 760  retry:
                         need_i_mutex = 0;                          need_i_mutex = 0;
                 }                  }
   
                 xfs_rw_enter_trace(XFS_DIOWR_ENTER, io, (void *)iovp, segs,                  xfs_rw_enter_trace(XFS_DIOWR_ENTER, xip, (void *)iovp, segs,
                                 *offset, ioflags);                                  *offset, ioflags);
                 ret = generic_file_direct_write(iocb, iovp,                  ret = generic_file_direct_write(iocb, iovp,
                                 &segs, pos, offset, count, ocount);                                  &segs, pos, offset, count, ocount);
Line 787  retry: Line 780  retry:
                         goto relock;                          goto relock;
                 }                  }
         } else {          } else {
                 xfs_rw_enter_trace(XFS_WRITE_ENTER, io, (void *)iovp, segs,                  xfs_rw_enter_trace(XFS_WRITE_ENTER, xip, (void *)iovp, segs,
                                 *offset, ioflags);                                  *offset, ioflags);
                 ret = generic_file_buffered_write(iocb, iovp, segs,                  ret = generic_file_buffered_write(iocb, iovp, segs,
                                 pos, offset, count, ret);                                  pos, offset, count, ret);
Line 851  retry: Line 844  retry:
         }          }
   
  out_unlock_internal:   out_unlock_internal:
         if (io->io_new_size) {          if (xip->i_new_size) {
                 xfs_ilock(xip, XFS_ILOCK_EXCL);                  xfs_ilock(xip, XFS_ILOCK_EXCL);
                 io->io_new_size = 0;                  xip->i_new_size = 0;
                 /*                  /*
                  * If this was a direct or synchronous I/O that failed (such                   * If this was a direct or synchronous I/O that failed (such
                  * as ENOSPC) then part of the I/O may have been written to                   * as ENOSPC) then part of the I/O may have been written to
Removed from v.1.269  
changed lines
  Added in v.1.270

FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>