xfs: remove the xfs_disk_dquot_t and xfs_dquot_t

Signed-off-by: Pavel Reichl <preichl@redhat.com>
Reviewed-by: Darrick J. Wong <darrick.wong@oracle.com>
[darrick: fix some of the comments]
Signed-off-by: Darrick J. Wong <darrick.wong@oracle.com>

diff --git a/fs/xfs/libxfs/xfs_dquot_buf.c b/fs/xfs/libxfs/xfs_dquot_buf.c
index e8bd688a4073d909df133b806ce7d79c27e00090..bedc1e752b601f0c569896af4d30a6844697bae9 100644 (file)
--- a/fs/xfs/libxfs/xfs_dquot_buf.c
+++ b/fs/xfs/libxfs/xfs_dquot_buf.c
@@ -35,10 +35,10 @@ xfs_calc_dquots_per_chunk(
 
 xfs_failaddr_t
 xfs_dquot_verify(
-       struct xfs_mount *mp,
-       xfs_disk_dquot_t *ddq,
-       xfs_dqid_t       id,
-       uint             type)    /* used only during quotacheck */
+       struct xfs_mount        *mp,
+       struct xfs_disk_dquot   *ddq,
+       xfs_dqid_t              id,
+       uint                    type)   /* used only during quotacheck */
 {
        /*
         * We can encounter an uninitialized dquot buffer for 2 reasons:

diff --git a/fs/xfs/libxfs/xfs_format.h b/fs/xfs/libxfs/xfs_format.h
index c968b60cee15bf14d8d6d590db9e8e83802ce117..4cae17f35e94069b6762c2a68d04f42e53ecd2da 100644 (file)
--- a/fs/xfs/libxfs/xfs_format.h
+++ b/fs/xfs/libxfs/xfs_format.h
@@ -1144,11 +1144,11 @@ static inline void xfs_dinode_put_rdev(struct xfs_dinode *dip, xfs_dev_t rdev)
 
 /*
  * This is the main portion of the on-disk representation of quota
- * information for a user. This is the q_core of the xfs_dquot_t that
+ * information for a user. This is the q_core of the struct xfs_dquot that
  * is kept in kernel memory. We pad this with some more expansion room
  * to construct the on disk structure.
  */
-typedef struct xfs_disk_dquot {
+struct xfs_disk_dquot {
        __be16          d_magic;        /* dquot magic = XFS_DQUOT_MAGIC */
        __u8            d_version;      /* dquot version */
        __u8            d_flags;        /* XFS_DQ_USER/PROJ/GROUP */
@@ -1171,15 +1171,15 @@ typedef struct  xfs_disk_dquot {
        __be32          d_rtbtimer;     /* similar to above; for RT disk blocks */
        __be16          d_rtbwarns;     /* warnings issued wrt RT disk blocks */
        __be16          d_pad;
-} xfs_disk_dquot_t;
+};
 
 /*
  * This is what goes on disk. This is separated from the xfs_disk_dquot because
  * carrying the unnecessary padding would be a waste of memory.
  */
 typedef struct xfs_dqblk {
-       xfs_disk_dquot_t  dd_diskdq;    /* portion that lives incore as well */
-       char              dd_fill[4];   /* filling for posterity */
+       struct xfs_disk_dquot   dd_diskdq; /* portion living incore as well */
+       char                    dd_fill[4];/* filling for posterity */
 
        /*
         * These two are only present on filesystems with the CRC bits set.

diff --git a/fs/xfs/libxfs/xfs_trans_resv.c b/fs/xfs/libxfs/xfs_trans_resv.c
index d12bbd526e7c02ff21eaf07c37a09d1d3b13ad51..fbdb3b89b703dce20f32b4ae2ecd50fa7cf158e1 100644 (file)
--- a/fs/xfs/libxfs/xfs_trans_resv.c
+++ b/fs/xfs/libxfs/xfs_trans_resv.c
@@ -718,7 +718,7 @@ xfs_calc_clear_agi_bucket_reservation(
 
 /*
  * Adjusting quota limits.
- *    the xfs_disk_dquot_t: sizeof(struct xfs_disk_dquot)
+ *    the disk quota buffer: sizeof(struct xfs_disk_dquot)
  */
 STATIC uint
 xfs_calc_qm_setqlim_reservation(void)

diff --git a/fs/xfs/xfs_dquot.c b/fs/xfs/xfs_dquot.c
index 091faaa5f8ba86080b9015ab5b005f68298812d0..14396171121601e3ad3140ca2d0b1d05a625c55e 100644 (file)
--- a/fs/xfs/xfs_dquot.c
+++ b/fs/xfs/xfs_dquot.c
@@ -48,7 +48,7 @@ static struct lock_class_key xfs_dquot_project_class;
  */
 void
 xfs_qm_dqdestroy(
-       xfs_dquot_t     *dqp)
+       struct xfs_dquot        *dqp)
 {
        ASSERT(list_empty(&dqp->q_lru));
 
@@ -113,8 +113,8 @@ xfs_qm_adjust_dqlimits(
  */
 void
 xfs_qm_adjust_dqtimers(
-       xfs_mount_t             *mp,
-       xfs_disk_dquot_t        *d)
+       struct xfs_mount        *mp,
+       struct xfs_disk_dquot   *d)
 {
        ASSERT(d->d_id);
 
@@ -497,7 +497,7 @@ xfs_dquot_from_disk(
        struct xfs_disk_dquot   *ddqp = bp->b_addr + dqp->q_bufoffset;
 
        /* copy everything from disk dquot to the incore dquot */
-       memcpy(&dqp->q_core, ddqp, sizeof(xfs_disk_dquot_t));
+       memcpy(&dqp->q_core, ddqp, sizeof(struct xfs_disk_dquot));
 
        /*
         * Reservation counters are defined as reservation plus current usage
@@ -989,7 +989,7 @@ xfs_qm_dqput(
  */
 void
 xfs_qm_dqrele(
-       xfs_dquot_t     *dqp)
+       struct xfs_dquot        *dqp)
 {
        if (!dqp)
                return;
@@ -1019,7 +1019,7 @@ xfs_qm_dqflush_done(
        struct xfs_log_item     *lip)
 {
        xfs_dq_logitem_t        *qip = (struct xfs_dq_logitem *)lip;
-       xfs_dquot_t             *dqp = qip->qli_dquot;
+       struct xfs_dquot        *dqp = qip->qli_dquot;
        struct xfs_ail          *ailp = lip->li_ailp;
 
        /*
@@ -1130,7 +1130,7 @@ xfs_qm_dqflush(
        }
 
        /* This is the only portion of data that needs to persist */
-       memcpy(ddqp, &dqp->q_core, sizeof(xfs_disk_dquot_t));
+       memcpy(ddqp, &dqp->q_core, sizeof(struct xfs_disk_dquot));
 
        /*
         * Clear the dirty field and remember the flush lsn for later use.
@@ -1188,8 +1188,8 @@ out_unlock:
  */
 void
 xfs_dqlock2(
-       xfs_dquot_t     *d1,
-       xfs_dquot_t     *d2)
+       struct xfs_dquot        *d1,
+       struct xfs_dquot        *d2)
 {
        if (d1 && d2) {
                ASSERT(d1 != d2);

diff --git a/fs/xfs/xfs_dquot.h b/fs/xfs/xfs_dquot.h
index 4fe85709d55d245fb65f72c6bd87866c1d5c5ba4..831e4270cf6536ff3b3d6f392a3d37299b0dfdc3 100644 (file)
--- a/fs/xfs/xfs_dquot.h
+++ b/fs/xfs/xfs_dquot.h
@@ -30,33 +30,36 @@ enum {
 /*
  * The incore dquot structure
  */
-typedef struct xfs_dquot {
-       uint             dq_flags;      /* various flags (XFS_DQ_*) */
-       struct list_head q_lru;         /* global free list of dquots */
-       struct xfs_mount*q_mount;       /* filesystem this relates to */
-       uint             q_nrefs;       /* # active refs from inodes */
-       xfs_daddr_t      q_blkno;       /* blkno of dquot buffer */
-       int              q_bufoffset;   /* off of dq in buffer (# dquots) */
-       xfs_fileoff_t    q_fileoffset;  /* offset in quotas file */
-
-       xfs_disk_dquot_t q_core;        /* actual usage & quotas */
-       xfs_dq_logitem_t q_logitem;     /* dquot log item */
-       xfs_qcnt_t       q_res_bcount;  /* total regular nblks used+reserved */
-       xfs_qcnt_t       q_res_icount;  /* total inos allocd+reserved */
-       xfs_qcnt_t       q_res_rtbcount;/* total realtime blks used+reserved */
-       xfs_qcnt_t       q_prealloc_lo_wmark;/* prealloc throttle wmark */
-       xfs_qcnt_t       q_prealloc_hi_wmark;/* prealloc disabled wmark */
-       int64_t          q_low_space[XFS_QLOWSP_MAX];
-       struct mutex     q_qlock;       /* quota lock */
-       struct completion q_flush;      /* flush completion queue */
-       atomic_t          q_pincount;   /* dquot pin count */
-       wait_queue_head_t q_pinwait;    /* dquot pinning wait queue */
-} xfs_dquot_t;
+struct xfs_dquot {
+       uint                    dq_flags;
+       struct list_head        q_lru;
+       struct xfs_mount        *q_mount;
+       uint                    q_nrefs;
+       xfs_daddr_t             q_blkno;
+       int                     q_bufoffset;
+       xfs_fileoff_t           q_fileoffset;
+
+       struct xfs_disk_dquot   q_core;
+       xfs_dq_logitem_t        q_logitem;
+       /* total regular nblks used+reserved */
+       xfs_qcnt_t              q_res_bcount;
+       /* total inos allocd+reserved */
+       xfs_qcnt_t              q_res_icount;
+       /* total realtime blks used+reserved */
+       xfs_qcnt_t              q_res_rtbcount;
+       xfs_qcnt_t              q_prealloc_lo_wmark;
+       xfs_qcnt_t              q_prealloc_hi_wmark;
+       int64_t                 q_low_space[XFS_QLOWSP_MAX];
+       struct mutex            q_qlock;
+       struct completion       q_flush;
+       atomic_t                q_pincount;
+       struct wait_queue_head  q_pinwait;
+};
 
 /*
  * Lock hierarchy for q_qlock:
  *     XFS_QLOCK_NORMAL is the implicit default,
- *     XFS_QLOCK_NESTED is the dquot with the higher id in xfs_dqlock2
+ *     XFS_QLOCK_NESTED is the dquot with the higher id in xfs_dqlock2
  */
 enum {
        XFS_QLOCK_NORMAL = 0,
@@ -64,21 +67,21 @@ enum {
 };
 
 /*
- * Manage the q_flush completion queue embedded in the dquot.  This completion
+ * Manage the q_flush completion queue embedded in the dquot. This completion
  * queue synchronizes processes attempting to flush the in-core dquot back to
  * disk.
  */
-static inline void xfs_dqflock(xfs_dquot_t *dqp)
+static inline void xfs_dqflock(struct xfs_dquot *dqp)
 {
        wait_for_completion(&dqp->q_flush);
 }
 
-static inline bool xfs_dqflock_nowait(xfs_dquot_t *dqp)
+static inline bool xfs_dqflock_nowait(struct xfs_dquot *dqp)
 {
        return try_wait_for_completion(&dqp->q_flush);
 }
 
-static inline void xfs_dqfunlock(xfs_dquot_t *dqp)
+static inline void xfs_dqfunlock(struct xfs_dquot *dqp)
 {
        complete(&dqp->q_flush);
 }
@@ -112,7 +115,7 @@ static inline int xfs_this_quota_on(struct xfs_mount *mp, int type)
        }
 }
 
-static inline xfs_dquot_t *xfs_inode_dquot(struct xfs_inode *ip, int type)
+static inline struct xfs_dquot *xfs_inode_dquot(struct xfs_inode *ip, int type)
 {
        switch (type & XFS_DQ_ALLTYPES) {
        case XFS_DQ_USER:
@@ -147,31 +150,30 @@ static inline bool xfs_dquot_lowsp(struct xfs_dquot *dqp)
 #define XFS_QM_ISPDQ(dqp)      ((dqp)->dq_flags & XFS_DQ_PROJ)
 #define XFS_QM_ISGDQ(dqp)      ((dqp)->dq_flags & XFS_DQ_GROUP)
 
-extern void            xfs_qm_dqdestroy(xfs_dquot_t *);
-extern int             xfs_qm_dqflush(struct xfs_dquot *, struct xfs_buf **);
-extern void            xfs_qm_dqunpin_wait(xfs_dquot_t *);
-extern void            xfs_qm_adjust_dqtimers(xfs_mount_t *,
-                                       xfs_disk_dquot_t *);
-extern void            xfs_qm_adjust_dqlimits(struct xfs_mount *,
-                                              struct xfs_dquot *);
-extern xfs_dqid_t      xfs_qm_id_for_quotatype(struct xfs_inode *ip,
-                                       uint type);
-extern int             xfs_qm_dqget(struct xfs_mount *mp, xfs_dqid_t id,
+void           xfs_qm_dqdestroy(struct xfs_dquot *dqp);
+int            xfs_qm_dqflush(struct xfs_dquot *dqp, struct xfs_buf **bpp);
+void           xfs_qm_dqunpin_wait(struct xfs_dquot *dqp);
+void           xfs_qm_adjust_dqtimers(struct xfs_mount *mp,
+                                               struct xfs_disk_dquot *d);
+void           xfs_qm_adjust_dqlimits(struct xfs_mount *mp,
+                                               struct xfs_dquot *d);
+xfs_dqid_t     xfs_qm_id_for_quotatype(struct xfs_inode *ip, uint type);
+int            xfs_qm_dqget(struct xfs_mount *mp, xfs_dqid_t id,
                                        uint type, bool can_alloc,
                                        struct xfs_dquot **dqpp);
-extern int             xfs_qm_dqget_inode(struct xfs_inode *ip, uint type,
-                                       bool can_alloc,
-                                       struct xfs_dquot **dqpp);
-extern int             xfs_qm_dqget_next(struct xfs_mount *mp, xfs_dqid_t id,
+int            xfs_qm_dqget_inode(struct xfs_inode *ip, uint type,
+                                               bool can_alloc,
+                                               struct xfs_dquot **dqpp);
+int            xfs_qm_dqget_next(struct xfs_mount *mp, xfs_dqid_t id,
                                        uint type, struct xfs_dquot **dqpp);
-extern int             xfs_qm_dqget_uncached(struct xfs_mount *mp,
-                                       xfs_dqid_t id, uint type,
-                                       struct xfs_dquot **dqpp);
-extern void            xfs_qm_dqput(xfs_dquot_t *);
+int            xfs_qm_dqget_uncached(struct xfs_mount *mp,
+                                               xfs_dqid_t id, uint type,
+                                               struct xfs_dquot **dqpp);
+void           xfs_qm_dqput(struct xfs_dquot *dqp);
 
-extern void            xfs_dqlock2(struct xfs_dquot *, struct xfs_dquot *);
+void           xfs_dqlock2(struct xfs_dquot *, struct xfs_dquot *);
 
-extern void            xfs_dquot_set_prealloc_limits(struct xfs_dquot *);
+void           xfs_dquot_set_prealloc_limits(struct xfs_dquot *);
 
 static inline struct xfs_dquot *xfs_qm_dqhold(struct xfs_dquot *dqp)
 {

diff --git a/fs/xfs/xfs_log_recover.c b/fs/xfs/xfs_log_recover.c
index a008e33494832e83d1ccfa45e80b3d53a4f38c4d..75d5c15b10d0494731d257ecc0e8f47dbd0a6f62 100644 (file)
--- a/fs/xfs/xfs_log_recover.c
+++ b/fs/xfs/xfs_log_recover.c
@@ -2567,6 +2567,7 @@ xlog_recover_do_reg_buffer(
        int                     bit;
        int                     nbits;
        xfs_failaddr_t          fa;
+       const size_t            size_disk_dquot = sizeof(struct xfs_disk_dquot);
 
        trace_xfs_log_recover_buf_reg_buf(mp->m_log, buf_f);
 
@@ -2609,7 +2610,7 @@ xlog_recover_do_reg_buffer(
                                        "XFS: NULL dquot in %s.", __func__);
                                goto next;
                        }
-                       if (item->ri_buf[i].i_len < sizeof(xfs_disk_dquot_t)) {
+                       if (item->ri_buf[i].i_len < size_disk_dquot) {
                                xfs_alert(mp,
                                        "XFS: dquot too small (%d) in %s.",
                                        item->ri_buf[i].i_len, __func__);
@@ -3236,7 +3237,7 @@ xlog_recover_dquot_pass2(
                xfs_alert(log->l_mp, "NULL dquot in %s.", __func__);
                return -EFSCORRUPTED;
        }
-       if (item->ri_buf[1].i_len < sizeof(xfs_disk_dquot_t)) {
+       if (item->ri_buf[1].i_len < sizeof(struct xfs_disk_dquot)) {
                xfs_alert(log->l_mp, "dquot too small (%d) in %s.",
                        item->ri_buf[1].i_len, __func__);
                return -EFSCORRUPTED;

diff --git a/fs/xfs/xfs_qm.c b/fs/xfs/xfs_qm.c
index de346d560bbfd7791fcab4334403eaf4dd7566bd..98b369025d9868b2f2a244b4d093003488aa5881 100644 (file)
--- a/fs/xfs/xfs_qm.c
+++ b/fs/xfs/xfs_qm.c
@@ -244,14 +244,14 @@ xfs_qm_unmount_quotas(
 
 STATIC int
 xfs_qm_dqattach_one(
-       xfs_inode_t     *ip,
-       xfs_dqid_t      id,
-       uint            type,
-       bool            doalloc,
-       xfs_dquot_t     **IO_idqpp)
+       struct xfs_inode        *ip,
+       xfs_dqid_t              id,
+       uint                    type,
+       bool                    doalloc,
+       struct xfs_dquot        **IO_idqpp)
 {
-       xfs_dquot_t     *dqp;
-       int             error;
+       struct xfs_dquot        *dqp;
+       int                     error;
 
        ASSERT(xfs_isilocked(ip, XFS_ILOCK_EXCL));
        error = 0;
@@ -544,8 +544,8 @@ xfs_qm_set_defquota(
        uint            type,
        xfs_quotainfo_t *qinf)
 {
-       xfs_dquot_t             *dqp;
-       struct xfs_def_quota    *defq;
+       struct xfs_dquot        *dqp;
+       struct xfs_def_quota    *defq;
        struct xfs_disk_dquot   *ddqp;
        int                     error;
 
@@ -1742,14 +1742,14 @@ error_rele:
  * Actually transfer ownership, and do dquot modifications.
  * These were already reserved.
  */
-xfs_dquot_t *
+struct xfs_dquot *
 xfs_qm_vop_chown(
-       xfs_trans_t     *tp,
-       xfs_inode_t     *ip,
-       xfs_dquot_t     **IO_olddq,
-       xfs_dquot_t     *newdq)
+       struct xfs_trans        *tp,
+       struct xfs_inode        *ip,
+       struct xfs_dquot        **IO_olddq,
+       struct xfs_dquot        *newdq)
 {
-       xfs_dquot_t     *prevdq;
+       struct xfs_dquot        *prevdq;
        uint            bfield = XFS_IS_REALTIME_INODE(ip) ?
                                 XFS_TRANS_DQ_RTBCOUNT : XFS_TRANS_DQ_BCOUNT;
 

diff --git a/fs/xfs/xfs_qm_bhv.c b/fs/xfs/xfs_qm_bhv.c
index ac8885d0f752c51d814161a778d41ba30e2950ec..fc2fa418919f7ffd7537f05ef860712d80ceb3f5 100644 (file)
--- a/fs/xfs/xfs_qm_bhv.c
+++ b/fs/xfs/xfs_qm_bhv.c
@@ -54,11 +54,11 @@ xfs_fill_statvfs_from_dquot(
  */
 void
 xfs_qm_statvfs(
-       xfs_inode_t             *ip,
+       struct xfs_inode        *ip,
        struct kstatfs          *statp)
 {
-       xfs_mount_t             *mp = ip->i_mount;
-       xfs_dquot_t             *dqp;
+       struct xfs_mount        *mp = ip->i_mount;
+       struct xfs_dquot        *dqp;
 
        if (!xfs_qm_dqget(mp, ip->i_d.di_projid, XFS_DQ_PROJ, false, &dqp)) {
                xfs_fill_statvfs_from_dquot(statp, dqp);

diff --git a/fs/xfs/xfs_trans_dquot.c b/fs/xfs/xfs_trans_dquot.c
index 16457465833ba3bb8a92880a48f80648d7f0708d..0b7f6f228662006836923f161ac52c479af4e673 100644 (file)
--- a/fs/xfs/xfs_trans_dquot.c
+++ b/fs/xfs/xfs_trans_dquot.c
@@ -25,8 +25,8 @@ STATIC void   xfs_trans_alloc_dqinfo(xfs_trans_t *);
  */
 void
 xfs_trans_dqjoin(
-       xfs_trans_t     *tp,
-       xfs_dquot_t     *dqp)
+       struct xfs_trans        *tp,
+       struct xfs_dquot        *dqp)
 {
        ASSERT(XFS_DQ_IS_LOCKED(dqp));
        ASSERT(dqp->q_logitem.qli_dquot == dqp);
@@ -49,8 +49,8 @@ xfs_trans_dqjoin(
  */
 void
 xfs_trans_log_dquot(
-       xfs_trans_t     *tp,
-       xfs_dquot_t     *dqp)
+       struct xfs_trans        *tp,
+       struct xfs_dquot        *dqp)
 {
        ASSERT(XFS_DQ_IS_LOCKED(dqp));
 
@@ -486,12 +486,12 @@ xfs_trans_apply_dquot_deltas(
  */
 void
 xfs_trans_unreserve_and_mod_dquots(
-       xfs_trans_t             *tp)
+       struct xfs_trans        *tp)
 {
        int                     i, j;
-       xfs_dquot_t             *dqp;
+       struct xfs_dquot        *dqp;
        struct xfs_dqtrx        *qtrx, *qa;
-       bool                    locked;
+       bool                    locked;
 
        if (!tp->t_dqinfo || !(tp->t_flags & XFS_TRANS_DQ_DIRTY))
                return;
@@ -571,21 +571,21 @@ xfs_quota_warn(
  */
 STATIC int
 xfs_trans_dqresv(
-       xfs_trans_t     *tp,
-       xfs_mount_t     *mp,
-       xfs_dquot_t     *dqp,
-       int64_t         nblks,
-       long            ninos,
-       uint            flags)
+       struct xfs_trans        *tp,
+       struct xfs_mount        *mp,
+       struct xfs_dquot        *dqp,
+       int64_t                 nblks,
+       long                    ninos,
+       uint                    flags)
 {
-       xfs_qcnt_t      hardlimit;
-       xfs_qcnt_t      softlimit;
-       time_t          timer;
-       xfs_qwarncnt_t  warns;
-       xfs_qwarncnt_t  warnlimit;
-       xfs_qcnt_t      total_count;
-       xfs_qcnt_t      *resbcountp;
-       xfs_quotainfo_t *q = mp->m_quotainfo;
+       xfs_qcnt_t              hardlimit;
+       xfs_qcnt_t              softlimit;
+       time_t                  timer;
+       xfs_qwarncnt_t          warns;
+       xfs_qwarncnt_t          warnlimit;
+       xfs_qcnt_t              total_count;
+       xfs_qcnt_t              *resbcountp;
+       xfs_quotainfo_t         *q = mp->m_quotainfo;
        struct xfs_def_quota    *defq;