← Back to branch summary

~clint-fewbar/+junk/ceph-packaging

« back to all changes in this revision

Viewing changes to src/messages/MClientCaps.h

  • Committer: Clint Byrum
  • Date: 2010-07-21 04:26:29 UTC
  • Revision ID: clint@ubuntu.com-20100721042629-srvi3wzjib97px3o
importing upstream v0.20.2

Show diffs side-by-side

added added

removed removed

Lines of Context:
src/messages/MClientCaps.h
 
1
// -*- mode:C++; tab-width:8; c-basic-offset:2; indent-tabs-mode:t -*- 
 
2
// vim: ts=8 sw=2 smarttab
 
3
/*
 
4
 * Ceph - scalable distributed file system
 
5
 *
 
6
 * Copyright (C) 2004-2006 Sage Weil <sage@newdream.net>
 
7
 *
 
8
 * This is free software; you can redistribute it and/or
 
9
 * modify it under the terms of the GNU Lesser General Public
 
10
 * License version 2.1, as published by the Free Software 
 
11
 * Foundation.  See file COPYING.
 
12
 * 
 
13
 */
 
14
 
 
15
#ifndef __MCLIENTCAPS_H
 
16
#define __MCLIENTCAPS_H
 
17
 
 
18
#include "msg/Message.h"
 
19
 
 
20
 
 
21
class MClientCaps : public Message {
 
22
 public:
 
23
  struct ceph_mds_caps head;
 
24
  bufferlist snapbl;
 
25
  bufferlist xattrbl;
 
26
 
 
27
  int      get_caps() { return head.caps; }
 
28
  int      get_wanted() { return head.wanted; }
 
29
  int      get_dirty() { return head.dirty; }
 
30
  ceph_seq_t get_seq() { return head.seq; }
 
31
  ceph_seq_t get_issue_seq() { return head.issue_seq; }
 
32
  ceph_seq_t get_mseq() { return head.migrate_seq; }
 
33
 
 
34
  inodeno_t get_ino() { return inodeno_t(head.ino); }
 
35
  inodeno_t get_realm() { return inodeno_t(head.realm); }
 
36
  uint64_t get_cap_id() { return head.cap_id; }
 
37
 
 
38
  uint64_t get_size() { return head.size;  }
 
39
  uint64_t get_max_size() { return head.max_size;  }
 
40
  __u32 get_truncate_seq() { return head.truncate_seq; }
 
41
  uint64_t get_truncate_size() { return head.truncate_size; }
 
42
  utime_t get_ctime() { return utime_t(head.ctime); }
 
43
  utime_t get_mtime() { return utime_t(head.mtime); }
 
44
  utime_t get_atime() { return utime_t(head.atime); }
 
45
  __u32 get_time_warp_seq() { return head.time_warp_seq; }
 
46
 
 
47
  ceph_file_layout& get_layout() { return head.layout; }
 
48
 
 
49
  int       get_migrate_seq() { return head.migrate_seq; }
 
50
  int       get_op() { return head.op; }
 
51
 
 
52
  uint64_t get_client_tid() { return get_tid(); }
 
53
  void set_client_tid(uint64_t s) { set_tid(s); }
 
54
 
 
55
  snapid_t get_snap_follows() { return snapid_t(head.snap_follows); }
 
56
  void set_snap_follows(snapid_t s) { head.snap_follows = s; }
 
57
 
 
58
  void set_caps(int c) { head.caps = c; }
 
59
  void set_wanted(int w) { head.wanted = w; }
 
60
 
 
61
  void set_max_size(uint64_t ms) { head.max_size = ms; }
 
62
 
 
63
  void set_migrate_seq(unsigned m) { head.migrate_seq = m; }
 
64
  void set_op(int o) { head.op = o; }
 
65
 
 
66
  void set_size(loff_t s) { head.size = s; }
 
67
  void set_mtime(const utime_t &t) { t.encode_timeval(&head.mtime); }
 
68
  void set_atime(const utime_t &t) { t.encode_timeval(&head.atime); }
 
69
 
 
70
  MClientCaps() {}
 
71
  MClientCaps(int op,
 
72
              inodeno_t ino,
 
73
              inodeno_t realm,
 
74
              uint64_t id,
 
75
              long seq,
 
76
              int caps,
 
77
              int wanted,
 
78
              int dirty,
 
79
              int mseq) :
 
80
    Message(CEPH_MSG_CLIENT_CAPS) {
 
81
    memset(&head, 0, sizeof(head));
 
82
    head.op = op;
 
83
    head.ino = ino;
 
84
    head.realm = realm;
 
85
    head.cap_id = id;
 
86
    head.seq = seq;
 
87
    head.caps = caps;
 
88
    head.wanted = wanted;
 
89
    head.dirty = dirty;
 
90
    head.migrate_seq = mseq;
 
91
  }
 
92
  MClientCaps(int op,
 
93
              inodeno_t ino, inodeno_t realm,
 
94
              uint64_t id, int mseq) :
 
95
    Message(CEPH_MSG_CLIENT_CAPS) {
 
96
    memset(&head, 0, sizeof(head));
 
97
    head.op = op;
 
98
    head.ino = ino;
 
99
    head.realm = realm;
 
100
    head.cap_id = id;
 
101
    head.migrate_seq = mseq;
 
102
  }
 
103
 
 
104
  const char *get_type_name() { return "Cfcap";}
 
105
  void print(ostream& out) {
 
106
    out << "client_caps(" << ceph_cap_op_name(head.op)
 
107
        << " ino " << inodeno_t(head.ino)
 
108
        << " " << head.cap_id
 
109
        << " seq " << head.seq 
 
110
        << " caps=" << ccap_string(head.caps)
 
111
        << " dirty=" << ccap_string(head.dirty)
 
112
        << " wanted=" << ccap_string(head.wanted);
 
113
    out << " follows " << snapid_t(head.snap_follows);
 
114
    if (head.migrate_seq)
 
115
      out << " mseq " << head.migrate_seq;
 
116
 
 
117
    out << " size " << head.size << "/" << head.max_size;
 
118
    if (head.truncate_seq)
 
119
      out << " ts " << head.truncate_seq;
 
120
    out << " mtime " << utime_t(head.mtime);
 
121
    if (head.time_warp_seq)
 
122
      out << " tws " << head.time_warp_seq;
 
123
 
 
124
    if (head.xattr_version)
 
125
      out << " xattrs(v=" << head.xattr_version << " l=" << xattrbl.length() << ")";
 
126
 
 
127
    out << ")";
 
128
  }
 
129
  
 
130
  void decode_payload() {
 
131
    bufferlist::iterator p = payload.begin();
 
132
    ::decode(head, p);
 
133
    ::decode_nohead(head.snap_trace_len, snapbl, p);
 
134
 
 
135
    assert(middle.length() == head.xattr_len);
 
136
    if (head.xattr_len)
 
137
      xattrbl = middle;
 
138
  }
 
139
  void encode_payload() {
 
140
    head.snap_trace_len = snapbl.length();
 
141
    head.xattr_len = xattrbl.length();
 
142
    ::encode(head, payload);
 
143
    ::encode_nohead(snapbl, payload);
 
144
 
 
145
    middle = xattrbl;
 
146
  }
 
147
};
 
148
 
 
149
#endif