← Back to branch summary

~ubuntu-branches/ubuntu/precise/linux-lowlatency/precise

« back to all changes in this revision

Viewing changes to fs/gfs2/lops.h

  • Committer: Package Import Robot
  • Author(s): Alessio Igor Bogani
  • Date: 2011-10-26 11:13:05 UTC
  • Revision ID: package-import@ubuntu.com-20111026111305-tz023xykf0i6eosh
Tags: upstream-3.2.0
Import upstream version 3.2.0

Show diffs side-by-side

added added

removed removed

Lines of Context:
fs/gfs2/lops.h
 
1
/*
 
2
 * Copyright (C) Sistina Software, Inc.  1997-2003 All rights reserved.
 
3
 * Copyright (C) 2004-2008 Red Hat, Inc.  All rights reserved.
 
4
 *
 
5
 * This copyrighted material is made available to anyone wishing to use,
 
6
 * modify, copy, or redistribute it subject to the terms and conditions
 
7
 * of the GNU General Public License version 2.
 
8
 */
 
9
 
 
10
#ifndef __LOPS_DOT_H__
 
11
#define __LOPS_DOT_H__
 
12
 
 
13
#include <linux/list.h>
 
14
#include "incore.h"
 
15
 
 
16
#define BUF_OFFSET \
 
17
        ((sizeof(struct gfs2_log_descriptor) + sizeof(__be64) - 1) & \
 
18
         ~(sizeof(__be64) - 1))
 
19
#define DATABUF_OFFSET \
 
20
        ((sizeof(struct gfs2_log_descriptor) + (2 * sizeof(__be64) - 1)) & \
 
21
         ~(2 * sizeof(__be64) - 1))
 
22
 
 
23
extern const struct gfs2_log_operations gfs2_glock_lops;
 
24
extern const struct gfs2_log_operations gfs2_buf_lops;
 
25
extern const struct gfs2_log_operations gfs2_revoke_lops;
 
26
extern const struct gfs2_log_operations gfs2_rg_lops;
 
27
extern const struct gfs2_log_operations gfs2_databuf_lops;
 
28
 
 
29
extern const struct gfs2_log_operations *gfs2_log_ops[];
 
30
 
 
31
static inline unsigned int buf_limit(struct gfs2_sbd *sdp)
 
32
{
 
33
        unsigned int limit;
 
34
 
 
35
        limit = (sdp->sd_sb.sb_bsize - BUF_OFFSET) / sizeof(__be64);
 
36
        return limit;
 
37
}
 
38
 
 
39
static inline unsigned int databuf_limit(struct gfs2_sbd *sdp)
 
40
{
 
41
        unsigned int limit;
 
42
 
 
43
        limit = (sdp->sd_sb.sb_bsize - DATABUF_OFFSET) / (2 * sizeof(__be64));
 
44
        return limit;
 
45
}
 
46
 
 
47
static inline void lops_init_le(struct gfs2_log_element *le,
 
48
                                const struct gfs2_log_operations *lops)
 
49
{
 
50
        INIT_LIST_HEAD(&le->le_list);
 
51
        le->le_ops = lops;
 
52
}
 
53
 
 
54
static inline void lops_add(struct gfs2_sbd *sdp, struct gfs2_log_element *le)
 
55
{
 
56
        if (le->le_ops->lo_add)
 
57
                le->le_ops->lo_add(sdp, le);
 
58
}
 
59
 
 
60
static inline void lops_before_commit(struct gfs2_sbd *sdp)
 
61
{
 
62
        int x;
 
63
        for (x = 0; gfs2_log_ops[x]; x++)
 
64
                if (gfs2_log_ops[x]->lo_before_commit)
 
65
                        gfs2_log_ops[x]->lo_before_commit(sdp);
 
66
}
 
67
 
 
68
static inline void lops_after_commit(struct gfs2_sbd *sdp, struct gfs2_ail *ai)
 
69
{
 
70
        int x;
 
71
        for (x = 0; gfs2_log_ops[x]; x++)
 
72
                if (gfs2_log_ops[x]->lo_after_commit)
 
73
                        gfs2_log_ops[x]->lo_after_commit(sdp, ai);
 
74
}
 
75
 
 
76
static inline void lops_before_scan(struct gfs2_jdesc *jd,
 
77
                                    struct gfs2_log_header_host *head,
 
78
                                    unsigned int pass)
 
79
{
 
80
        int x;
 
81
        for (x = 0; gfs2_log_ops[x]; x++)
 
82
                if (gfs2_log_ops[x]->lo_before_scan)
 
83
                        gfs2_log_ops[x]->lo_before_scan(jd, head, pass);
 
84
}
 
85
 
 
86
static inline int lops_scan_elements(struct gfs2_jdesc *jd, unsigned int start,
 
87
                                     struct gfs2_log_descriptor *ld,
 
88
                                     __be64 *ptr,
 
89
                                     unsigned int pass)
 
90
{
 
91
        int x, error;
 
92
        for (x = 0; gfs2_log_ops[x]; x++)
 
93
                if (gfs2_log_ops[x]->lo_scan_elements) {
 
94
                        error = gfs2_log_ops[x]->lo_scan_elements(jd, start,
 
95
                                                                  ld, ptr, pass);
 
96
                        if (error)
 
97
                                return error;
 
98
                }
 
99
 
 
100
        return 0;
 
101
}
 
102
 
 
103
static inline void lops_after_scan(struct gfs2_jdesc *jd, int error,
 
104
                                   unsigned int pass)
 
105
{
 
106
        int x;
 
107
        for (x = 0; gfs2_log_ops[x]; x++)
 
108
                if (gfs2_log_ops[x]->lo_before_scan)
 
109
                        gfs2_log_ops[x]->lo_after_scan(jd, error, pass);
 
110
}
 
111
 
 
112
#endif /* __LOPS_DOT_H__ */
 
113