← Back to branch summary

~ubuntu-branches/ubuntu/precise/linux-ti-omap4/precise

« back to all changes in this revision

Viewing changes to ubuntu/iscsitarget/param.c

  • Committer: Bazaar Package Importer
  • Author(s): Paolo Pisati
  • Date: 2011-06-29 15:23:51 UTC
  • mfrom: (26.1.1 natty-proposed)
  • Revision ID: james.westby@ubuntu.com-20110629152351-xs96tm303d95rpbk
Tags: 3.0.0-1200.2
* Rebased against 3.0.0-6.7
* BSP from TI based on 3.0.0

Show diffs side-by-side

added added

removed removed

Lines of Context:
ubuntu/iscsitarget/param.c
1
 
/*
2
 
 * (C) 2005 FUJITA Tomonori <tomof@acm.org>
3
 
 *
4
 
 * This code is licenced under the GPL.
5
 
 */
6
 
 
7
 
#include "iscsi.h"
8
 
#include "iscsi_dbg.h"
9
 
#include "digest.h"
10
 
 
11
 
struct target_type *target_type_array[] = {
12
 
        &disk_ops,
13
 
};
14
 
 
15
 
#define CHECK_PARAM(info, iparam, word, min, max)                       \
16
 
do {                                                                    \
17
 
        if (!info->partial || (info->partial & 1 << key_##word))        \
18
 
                if (iparam[key_##word] < min ||                         \
19
 
                        iparam[key_##word] > max) {                     \
20
 
                        eprintk("%s: %u is out of range (%u %u)\n",     \
21
 
                                #word, iparam[key_##word], min, max);   \
22
 
                        iparam[key_##word] = min;                       \
23
 
                }                                                       \
24
 
} while (0)
25
 
 
26
 
#define SET_PARAM(param, info, iparam, word)                            \
27
 
({                                                                      \
28
 
        int changed = 0;                                                \
29
 
        if (!info->partial || (info->partial & 1 << key_##word)) {      \
30
 
                if (param->word != iparam[key_##word])                  \
31
 
                        changed = 1;                                    \
32
 
                param->word = iparam[key_##word];                       \
33
 
        }                                                               \
34
 
        changed;                                                        \
35
 
})
36
 
 
37
 
#define GET_PARAM(param, info, iparam, word)                            \
38
 
do {                                                                    \
39
 
        iparam[key_##word] = param->word;                               \
40
 
} while (0)
41
 
 
42
 
static void sess_param_check(struct iscsi_param_info *info)
43
 
{
44
 
        u32 *iparam = info->session_param;
45
 
 
46
 
        CHECK_PARAM(info, iparam, max_connections, 1, 65535);
47
 
        CHECK_PARAM(info, iparam, max_recv_data_length, 512,
48
 
                    (u32) ((ISCSI_CONN_IOV_MAX - 1) * PAGE_CACHE_SIZE));
49
 
        CHECK_PARAM(info, iparam, max_xmit_data_length, 512,
50
 
                    (u32) ((ISCSI_CONN_IOV_MAX - 1) * PAGE_CACHE_SIZE));
51
 
        CHECK_PARAM(info, iparam, error_recovery_level, 0, 0);
52
 
        CHECK_PARAM(info, iparam, data_pdu_inorder, 1, 1);
53
 
        CHECK_PARAM(info, iparam, data_sequence_inorder, 1, 1);
54
 
 
55
 
        digest_alg_available(&iparam[key_header_digest]);
56
 
        digest_alg_available(&iparam[key_data_digest]);
57
 
 
58
 
        CHECK_PARAM(info, iparam, ofmarker, 0, 0);
59
 
        CHECK_PARAM(info, iparam, ifmarker, 0, 0);
60
 
}
61
 
 
62
 
static void sess_param_set(struct iscsi_sess_param *param, struct iscsi_param_info *info)
63
 
{
64
 
        u32 *iparam = info->session_param;
65
 
 
66
 
        SET_PARAM(param, info, iparam, initial_r2t);
67
 
        SET_PARAM(param, info, iparam, immediate_data);
68
 
        SET_PARAM(param, info, iparam, max_connections);
69
 
        SET_PARAM(param, info, iparam, max_recv_data_length);
70
 
        SET_PARAM(param, info, iparam, max_xmit_data_length);
71
 
        SET_PARAM(param, info, iparam, max_burst_length);
72
 
        SET_PARAM(param, info, iparam, first_burst_length);
73
 
        SET_PARAM(param, info, iparam, default_wait_time);
74
 
        SET_PARAM(param, info, iparam, default_retain_time);
75
 
        SET_PARAM(param, info, iparam, max_outstanding_r2t);
76
 
        SET_PARAM(param, info, iparam, data_pdu_inorder);
77
 
        SET_PARAM(param, info, iparam, data_sequence_inorder);
78
 
        SET_PARAM(param, info, iparam, error_recovery_level);
79
 
        SET_PARAM(param, info, iparam, header_digest);
80
 
        SET_PARAM(param, info, iparam, data_digest);
81
 
        SET_PARAM(param, info, iparam, ofmarker);
82
 
        SET_PARAM(param, info, iparam, ifmarker);
83
 
        SET_PARAM(param, info, iparam, ofmarkint);
84
 
        SET_PARAM(param, info, iparam, ifmarkint);
85
 
}
86
 
 
87
 
static void sess_param_get(struct iscsi_sess_param *param, struct iscsi_param_info *info)
88
 
{
89
 
        u32 *iparam = info->session_param;
90
 
 
91
 
        GET_PARAM(param, info, iparam, initial_r2t);
92
 
        GET_PARAM(param, info, iparam, immediate_data);
93
 
        GET_PARAM(param, info, iparam, max_connections);
94
 
        GET_PARAM(param, info, iparam, max_recv_data_length);
95
 
        GET_PARAM(param, info, iparam, max_xmit_data_length);
96
 
        GET_PARAM(param, info, iparam, max_burst_length);
97
 
        GET_PARAM(param, info, iparam, first_burst_length);
98
 
        GET_PARAM(param, info, iparam, default_wait_time);
99
 
        GET_PARAM(param, info, iparam, default_retain_time);
100
 
        GET_PARAM(param, info, iparam, max_outstanding_r2t);
101
 
        GET_PARAM(param, info, iparam, data_pdu_inorder);
102
 
        GET_PARAM(param, info, iparam, data_sequence_inorder);
103
 
        GET_PARAM(param, info, iparam, error_recovery_level);
104
 
        GET_PARAM(param, info, iparam, header_digest);
105
 
        GET_PARAM(param, info, iparam, data_digest);
106
 
        GET_PARAM(param, info, iparam, ofmarker);
107
 
        GET_PARAM(param, info, iparam, ifmarker);
108
 
        GET_PARAM(param, info, iparam, ofmarkint);
109
 
        GET_PARAM(param, info, iparam, ifmarkint);
110
 
}
111
 
 
112
 
static void trgt_param_check(struct iscsi_param_info *info)
113
 
{
114
 
        u32 *iparam = info->target_param;
115
 
 
116
 
        CHECK_PARAM(info, iparam, wthreads, MIN_NR_WTHREADS, MAX_NR_WTHREADS);
117
 
        CHECK_PARAM(info, iparam, target_type, 0,
118
 
                    (unsigned int) ARRAY_SIZE(target_type_array) - 1);
119
 
        CHECK_PARAM(info, iparam, queued_cmnds, MIN_NR_QUEUED_CMNDS,
120
 
                    MAX_NR_QUEUED_CMNDS);
121
 
        CHECK_PARAM(info, iparam, nop_interval, MIN_NOP_INTERVAL,
122
 
                    MAX_NOP_INTERVAL);
123
 
        CHECK_PARAM(info, iparam, nop_timeout, MIN_NOP_TIMEOUT,
124
 
                    MAX_NOP_TIMEOUT);
125
 
}
126
 
 
127
 
static void trgt_param_set(struct iscsi_target *target, struct iscsi_param_info *info)
128
 
{
129
 
        struct iscsi_trgt_param *param = &target->trgt_param;
130
 
        u32 *iparam = info->target_param;
131
 
 
132
 
        if (!worker_thread_pool &&
133
 
            SET_PARAM(param, info, iparam, wthreads))
134
 
                wthread_start(target->wthread_info,
135
 
                              target->trgt_param.wthreads, target->tid);
136
 
        SET_PARAM(param, info, iparam, target_type);
137
 
        SET_PARAM(param, info, iparam, queued_cmnds);
138
 
        SET_PARAM(param, info, iparam, nop_interval);
139
 
        SET_PARAM(param, info, iparam, nop_timeout);
140
 
}
141
 
 
142
 
static void trgt_param_get(struct iscsi_trgt_param *param, struct iscsi_param_info *info)
143
 
{
144
 
        u32 *iparam = info->target_param;
145
 
 
146
 
        GET_PARAM(param, info, iparam, wthreads);
147
 
        GET_PARAM(param, info, iparam, target_type);
148
 
        GET_PARAM(param, info, iparam, queued_cmnds);
149
 
        GET_PARAM(param, info, iparam, nop_interval);
150
 
        GET_PARAM(param, info, iparam, nop_timeout);
151
 
}
152
 
 
153
 
static int trgt_param(struct iscsi_target *target, struct iscsi_param_info *info, int set)
154
 
{
155
 
 
156
 
        if (set) {
157
 
                trgt_param_check(info);
158
 
                trgt_param_set(target, info);
159
 
        } else
160
 
                trgt_param_get(&target->trgt_param, info);
161
 
 
162
 
        return 0;
163
 
}
164
 
 
165
 
static int sess_param(struct iscsi_target *target, struct iscsi_param_info *info, int set)
166
 
{
167
 
        struct iscsi_session *session = NULL;
168
 
        struct iscsi_sess_param *param;
169
 
        int err = -ENOENT;
170
 
 
171
 
        if (set)
172
 
                sess_param_check(info);
173
 
 
174
 
        if (info->sid) {
175
 
                if (!(session = session_lookup(target, info->sid)))
176
 
                        goto out;
177
 
                param = &session->param;
178
 
        } else {
179
 
                param = &target->sess_param;
180
 
        }
181
 
 
182
 
        if (set) {
183
 
                sess_param_set(param, info);
184
 
                show_param(param);
185
 
        } else
186
 
                sess_param_get(param, info);
187
 
 
188
 
        err = 0;
189
 
out:
190
 
        return err;
191
 
}
192
 
 
193
 
int iscsi_param_set(struct iscsi_target *target, struct iscsi_param_info *info, int set)
194
 
{
195
 
        int err;
196
 
 
197
 
        if (info->param_type == key_session)
198
 
                err = sess_param(target, info, set);
199
 
        else if (info->param_type == key_target)
200
 
                err = trgt_param(target, info, set);
201
 
        else
202
 
                err = -EINVAL;
203
 
 
204
 
        return err;
205
 
}