ceph: define new argument structure for send_cap_msg

When we get to this many arguments, it's hard to work with positional
parameters. send_cap_msg is already at 25 arguments, with more needed.

Define a new args structure and pass a pointer to it to send_cap_msg.
Eventually it might make sense to embed one of these inside
ceph_cap_snap instead of tracking individual fields.

Signed-off-by: Jeff Layton <jlayton@redhat.com>
Reviewed-by: Yan, Zheng <zyan@redhat.com>

diff --git a/fs/ceph/caps.c b/fs/ceph/caps.c
index 483baab2b1704d38957989c34e4a013c666cc547..2bb183d764aeba90fc25d4bb9aa51e79553077c5 100644 (file)
--- a/fs/ceph/caps.c
+++ b/fs/ceph/caps.c
@@ -987,22 +987,27 @@ void __ceph_remove_cap(struct ceph_cap *cap, bool queue_release)
                __cap_delay_cancel(mdsc, ci);
 }
 
+struct cap_msg_args {
+       struct ceph_mds_session *session;
+       u64                     ino, cid, follows;
+       u64                     flush_tid, oldest_flush_tid, size, max_size;
+       u64                     xattr_version;
+       struct ceph_buffer      *xattr_buf;
+       struct timespec         atime, mtime, ctime;
+       int                     op, caps, wanted, dirty;
+       u32                     seq, issue_seq, mseq, time_warp_seq;
+       kuid_t                  uid;
+       kgid_t                  gid;
+       umode_t                 mode;
+       bool                    inline_data;
+};
+
 /*
  * Build and send a cap message to the given MDS.
  *
  * Caller should be holding s_mutex.
  */
-static int send_cap_msg(struct ceph_mds_session *session,
-                       u64 ino, u64 cid, int op,
-                       int caps, int wanted, int dirty,
-                       u32 seq, u64 flush_tid, u64 oldest_flush_tid,
-                       u32 issue_seq, u32 mseq, u64 size, u64 max_size,
-                       struct timespec *mtime, struct timespec *atime,
-                       struct timespec *ctime, u32 time_warp_seq,
-                       kuid_t uid, kgid_t gid, umode_t mode,
-                       u64 xattr_version,
-                       struct ceph_buffer *xattrs_buf,
-                       u64 follows, bool inline_data)
+static int send_cap_msg(struct cap_msg_args *arg)
 {
        struct ceph_mds_caps *fc;
        struct ceph_msg *msg;
@@ -1011,12 +1016,13 @@ static int send_cap_msg(struct ceph_mds_session *session,
 
        dout("send_cap_msg %s %llx %llx caps %s wanted %s dirty %s"
             " seq %u/%u tid %llu/%llu mseq %u follows %lld size %llu/%llu"
-            " xattr_ver %llu xattr_len %d\n", ceph_cap_op_name(op),
-            cid, ino, ceph_cap_string(caps), ceph_cap_string(wanted),
-            ceph_cap_string(dirty),
-            seq, issue_seq, flush_tid, oldest_flush_tid,
-            mseq, follows, size, max_size,
-            xattr_version, xattrs_buf ? (int)xattrs_buf->vec.iov_len : 0);
+            " xattr_ver %llu xattr_len %d\n", ceph_cap_op_name(arg->op),
+            arg->cid, arg->ino, ceph_cap_string(arg->caps),
+            ceph_cap_string(arg->wanted), ceph_cap_string(arg->dirty),
+            arg->seq, arg->issue_seq, arg->flush_tid, arg->oldest_flush_tid,
+            arg->mseq, arg->follows, arg->size, arg->max_size,
+            arg->xattr_version,
+            arg->xattr_buf ? (int)arg->xattr_buf->vec.iov_len : 0);
 
        /* flock buffer size + inline version + inline data size +
         * osd_epoch_barrier + oldest_flush_tid */
@@ -1027,56 +1033,53 @@ static int send_cap_msg(struct ceph_mds_session *session,
                return -ENOMEM;
 
        msg->hdr.version = cpu_to_le16(6);
-       msg->hdr.tid = cpu_to_le64(flush_tid);
+       msg->hdr.tid = cpu_to_le64(arg->flush_tid);
 
        fc = msg->front.iov_base;
        memset(fc, 0, sizeof(*fc));
 
-       fc->cap_id = cpu_to_le64(cid);
-       fc->op = cpu_to_le32(op);
-       fc->seq = cpu_to_le32(seq);
-       fc->issue_seq = cpu_to_le32(issue_seq);
-       fc->migrate_seq = cpu_to_le32(mseq);
-       fc->caps = cpu_to_le32(caps);
-       fc->wanted = cpu_to_le32(wanted);
-       fc->dirty = cpu_to_le32(dirty);
-       fc->ino = cpu_to_le64(ino);
-       fc->snap_follows = cpu_to_le64(follows);
-
-       fc->size = cpu_to_le64(size);
-       fc->max_size = cpu_to_le64(max_size);
-       if (mtime)
-               ceph_encode_timespec(&fc->mtime, mtime);
-       if (atime)
-               ceph_encode_timespec(&fc->atime, atime);
-       if (ctime)
-               ceph_encode_timespec(&fc->ctime, ctime);
-       fc->time_warp_seq = cpu_to_le32(time_warp_seq);
-
-       fc->uid = cpu_to_le32(from_kuid(&init_user_ns, uid));
-       fc->gid = cpu_to_le32(from_kgid(&init_user_ns, gid));
-       fc->mode = cpu_to_le32(mode);
-
-       fc->xattr_version = cpu_to_le64(xattr_version);
-       if (xattrs_buf) {
-               msg->middle = ceph_buffer_get(xattrs_buf);
-               fc->xattr_len = cpu_to_le32(xattrs_buf->vec.iov_len);
-               msg->hdr.middle_len = cpu_to_le32(xattrs_buf->vec.iov_len);
+       fc->cap_id = cpu_to_le64(arg->cid);
+       fc->op = cpu_to_le32(arg->op);
+       fc->seq = cpu_to_le32(arg->seq);
+       fc->issue_seq = cpu_to_le32(arg->issue_seq);
+       fc->migrate_seq = cpu_to_le32(arg->mseq);
+       fc->caps = cpu_to_le32(arg->caps);
+       fc->wanted = cpu_to_le32(arg->wanted);
+       fc->dirty = cpu_to_le32(arg->dirty);
+       fc->ino = cpu_to_le64(arg->ino);
+       fc->snap_follows = cpu_to_le64(arg->follows);
+
+       fc->size = cpu_to_le64(arg->size);
+       fc->max_size = cpu_to_le64(arg->max_size);
+       ceph_encode_timespec(&fc->mtime, &arg->mtime);
+       ceph_encode_timespec(&fc->atime, &arg->atime);
+       ceph_encode_timespec(&fc->ctime, &arg->ctime);
+       fc->time_warp_seq = cpu_to_le32(arg->time_warp_seq);
+
+       fc->uid = cpu_to_le32(from_kuid(&init_user_ns, arg->uid));
+       fc->gid = cpu_to_le32(from_kgid(&init_user_ns, arg->gid));
+       fc->mode = cpu_to_le32(arg->mode);
+
+       fc->xattr_version = cpu_to_le64(arg->xattr_version);
+       if (arg->xattr_buf) {
+               msg->middle = ceph_buffer_get(arg->xattr_buf);
+               fc->xattr_len = cpu_to_le32(arg->xattr_buf->vec.iov_len);
+               msg->hdr.middle_len = cpu_to_le32(arg->xattr_buf->vec.iov_len);
        }
 
        p = fc + 1;
        /* flock buffer size */
        ceph_encode_32(&p, 0);
        /* inline version */
-       ceph_encode_64(&p, inline_data ? 0 : CEPH_INLINE_NONE);
+       ceph_encode_64(&p, arg->inline_data ? 0 : CEPH_INLINE_NONE);
        /* inline data size */
        ceph_encode_32(&p, 0);
        /* osd_epoch_barrier */
        ceph_encode_32(&p, 0);
        /* oldest_flush_tid */
-       ceph_encode_64(&p, oldest_flush_tid);
+       ceph_encode_64(&p, arg->oldest_flush_tid);
 
-       ceph_con_send(&session->s_con, msg);
+       ceph_con_send(&arg->session->s_con, msg);
        return 0;
 }
 
@@ -1121,21 +1124,11 @@ static int __send_cap(struct ceph_mds_client *mdsc, struct ceph_cap *cap,
 {
        struct ceph_inode_info *ci = cap->ci;
        struct inode *inode = &ci->vfs_inode;
-       u64 cap_id = cap->cap_id;
-       int held, revoking, dropping, keep;
-       u64 follows, size, max_size;
-       u32 seq, issue_seq, mseq, time_warp_seq;
-       struct timespec mtime, atime, ctime;
+       struct cap_msg_args arg;
+       int held, revoking, dropping;
        int wake = 0;
-       umode_t mode;
-       kuid_t uid;
-       kgid_t gid;
-       struct ceph_mds_session *session;
-       u64 xattr_version = 0;
-       struct ceph_buffer *xattr_blob = NULL;
        int delayed = 0;
        int ret;
-       bool inline_data;
 
        held = cap->issued | cap->implemented;
        revoking = cap->implemented & ~cap->issued;
@@ -1148,7 +1141,7 @@ static int __send_cap(struct ceph_mds_client *mdsc, struct ceph_cap *cap,
             ceph_cap_string(revoking));
        BUG_ON((retain & CEPH_CAP_PIN) == 0);
 
-       session = cap->session;
+       arg.session = cap->session;
 
        /* don't release wanted unless we've waited a bit. */
        if ((ci->i_ceph_flags & CEPH_I_NODELAY) == 0 &&
@@ -1177,40 +1170,48 @@ static int __send_cap(struct ceph_mds_client *mdsc, struct ceph_cap *cap,
        cap->implemented &= cap->issued | used;
        cap->mds_wanted = want;
 
-       follows = flushing ? ci->i_head_snapc->seq : 0;
-
-       keep = cap->implemented;
-       seq = cap->seq;
-       issue_seq = cap->issue_seq;
-       mseq = cap->mseq;
-       size = inode->i_size;
-       ci->i_reported_size = size;
-       max_size = ci->i_wanted_max_size;
-       ci->i_requested_max_size = max_size;
-       mtime = inode->i_mtime;
-       atime = inode->i_atime;
-       ctime = inode->i_ctime;
-       time_warp_seq = ci->i_time_warp_seq;
-       uid = inode->i_uid;
-       gid = inode->i_gid;
-       mode = inode->i_mode;
+       arg.ino = ceph_vino(inode).ino;
+       arg.cid = cap->cap_id;
+       arg.follows = flushing ? ci->i_head_snapc->seq : 0;
+       arg.flush_tid = flush_tid;
+       arg.oldest_flush_tid = oldest_flush_tid;
+
+       arg.size = inode->i_size;
+       ci->i_reported_size = arg.size;
+       arg.max_size = ci->i_wanted_max_size;
+       ci->i_requested_max_size = arg.max_size;
 
        if (flushing & CEPH_CAP_XATTR_EXCL) {
                __ceph_build_xattrs_blob(ci);
-               xattr_blob = ci->i_xattrs.blob;
-               xattr_version = ci->i_xattrs.version;
+               arg.xattr_version = ci->i_xattrs.version;
+               arg.xattr_buf = ci->i_xattrs.blob;
+       } else {
+               arg.xattr_buf = NULL;
        }
 
-       inline_data = ci->i_inline_version != CEPH_INLINE_NONE;
+       arg.mtime = inode->i_mtime;
+       arg.atime = inode->i_atime;
+       arg.ctime = inode->i_ctime;
+
+       arg.op = op;
+       arg.caps = cap->implemented;
+       arg.wanted = want;
+       arg.dirty = flushing;
+
+       arg.seq = cap->seq;
+       arg.issue_seq = cap->issue_seq;
+       arg.mseq = cap->mseq;
+       arg.time_warp_seq = ci->i_time_warp_seq;
+
+       arg.uid = inode->i_uid;
+       arg.gid = inode->i_gid;
+       arg.mode = inode->i_mode;
+
+       arg.inline_data = ci->i_inline_version != CEPH_INLINE_NONE;
 
        spin_unlock(&ci->i_ceph_lock);
 
-       ret = send_cap_msg(session, ceph_vino(inode).ino, cap_id,
-               op, keep, want, flushing, seq,
-               flush_tid, oldest_flush_tid, issue_seq, mseq,
-               size, max_size, &mtime, &atime, &ctime, time_warp_seq,
-               uid, gid, mode, xattr_version, xattr_blob,
-               follows, inline_data);
+       ret = send_cap_msg(&arg);
        if (ret < 0) {
                dout("error sending cap msg, must requeue %p\n", inode);
                delayed = 1;
@@ -1227,15 +1228,41 @@ static inline int __send_flush_snap(struct inode *inode,
                                    struct ceph_cap_snap *capsnap,
                                    u32 mseq, u64 oldest_flush_tid)
 {
-       return send_cap_msg(session, ceph_vino(inode).ino, 0,
-                       CEPH_CAP_OP_FLUSHSNAP, capsnap->issued, 0,
-                       capsnap->dirty, 0, capsnap->cap_flush.tid,
-                       oldest_flush_tid, 0, mseq, capsnap->size, 0,
-                       &capsnap->mtime, &capsnap->atime,
-                       &capsnap->ctime, capsnap->time_warp_seq,
-                       capsnap->uid, capsnap->gid, capsnap->mode,
-                       capsnap->xattr_version, capsnap->xattr_blob,
-                       capsnap->follows, capsnap->inline_data);
+       struct cap_msg_args     arg;
+
+       arg.session = session;
+       arg.ino = ceph_vino(inode).ino;
+       arg.cid = 0;
+       arg.follows = capsnap->follows;
+       arg.flush_tid = capsnap->cap_flush.tid;
+       arg.oldest_flush_tid = oldest_flush_tid;
+
+       arg.size = capsnap->size;
+       arg.max_size = 0;
+       arg.xattr_version = capsnap->xattr_version;
+       arg.xattr_buf = capsnap->xattr_blob;
+
+       arg.atime = capsnap->atime;
+       arg.mtime = capsnap->mtime;
+       arg.ctime = capsnap->ctime;
+
+       arg.op = CEPH_CAP_OP_FLUSHSNAP;
+       arg.caps = capsnap->issued;
+       arg.wanted = 0;
+       arg.dirty = capsnap->dirty;
+
+       arg.seq = 0;
+       arg.issue_seq = 0;
+       arg.mseq = mseq;
+       arg.time_warp_seq = capsnap->time_warp_seq;
+
+       arg.uid = capsnap->uid;
+       arg.gid = capsnap->gid;
+       arg.mode = capsnap->mode;
+
+       arg.inline_data = capsnap->inline_data;
+
+       return send_cap_msg(&arg);
 }
 
 /*