summaryrefslogtreecommitdiffstats
path: root/xlators/performance/quick-read/src/quick-read.h
blob: 6058d523b639eb5efe57fc7efdfe435df325c655 (plain)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
/*
  Copyright (c) 2009-2011 Gluster, Inc. <http://www.gluster.com>
  This file is part of GlusterFS.

  GlusterFS is free software; you can redistribute it and/or modify
  it under the terms of the GNU General Public License as published
  by the Free Software Foundation; either version 3 of the License,
  or (at your option) any later version.

  GlusterFS is distributed in the hope that it will be useful, but
  WITHOUT ANY WARRANTY; without even the implied warranty of
  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  General Public License for more details.

  You should have received a copy of the GNU General Public License
  along with this program.  If not, see
  <http://www.gnu.org/licenses/>.
*/

#ifndef __QUICK_READ_H
#define __QUICK_READ_H

#ifndef _CONFIG_H
#define _CONFIG_H
#include "config.h"
#endif

#include "glusterfs.h"
#include "logging.h"
#include "dict.h"
#include "xlator.h"
#include "list.h"
#include "compat.h"
#include "compat-errno.h"
#include "common-utils.h"
#include "call-stub.h"
#include "defaults.h"
#include <libgen.h>
#include <sys/time.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <unistd.h>
#include <fnmatch.h>
#include "quick-read-mem-types.h"

struct qr_fd_ctx {
        char              opened;
        char              disabled;
        char              open_in_transit;
        char             *path;
        int               flags;
        int               wbflags;
        struct list_head  waiting_ops;
        gf_lock_t         lock;
        struct list_head  inode_list;
        struct list_head  tmp_list;
        fd_t             *fd;
        dict_t           *xdata;
};
typedef struct qr_fd_ctx qr_fd_ctx_t;

struct qr_local {
        char              is_open;
        char             *path;
        char              just_validated;
        fd_t             *fd;
        int               open_flags;
        int32_t           op_ret;
        int32_t           op_errno;
        uint32_t          open_count;
        call_stub_t      *stub;
        struct list_head  fd_list;
        gf_lock_t         lock;
};
typedef struct qr_local qr_local_t;

struct qr_dentry {
        char             *name;
        uuid_t            pargfid;
        struct list_head  unlink_list;
};
typedef struct qr_dentry qr_dentry_t;

struct qr_inode {
        dict_t           *xattr;
        inode_t          *inode;
        int               priority;
        struct iatt       stbuf;
        struct timeval    tv;
        struct list_head  lru;
        struct list_head  fd_list;
        struct list_head  unlinked_dentries;
};
typedef struct qr_inode qr_inode_t;

struct qr_priority {
        char             *pattern;
        int32_t           priority;
        struct list_head  list;
};
typedef struct qr_priority qr_priority_t;

struct qr_conf {
        uint64_t         max_file_size;
        int32_t          cache_timeout;
        uint64_t         cache_size;
        int              max_pri;
        struct list_head priority_list;
};
typedef struct qr_conf qr_conf_t;

struct qr_inode_table {
        uint64_t          cache_used;
        struct list_head *lru;
        gf_lock_t         lock;
};
typedef struct qr_inode_table qr_inode_table_t;

struct qr_private {
        qr_conf_t         conf;
        qr_inode_table_t  table;
        struct mem_pool  *dentry_pool;
};
typedef struct qr_private qr_private_t;

void qr_local_free (qr_local_t *local);

#define QR_STACK_UNWIND(op, frame, params ...) do {             \
                qr_local_t *__local = frame->local;             \
                frame->local = NULL;                            \
                STACK_UNWIND_STRICT (op, frame, params);        \
                qr_local_free (__local);                        \
        } while (0)

#endif /* #ifndef __QUICK_READ_H */