Commit | Line | Data |
---|---|---|
1e51764a AB |
1 | /* |
2 | * This file is part of UBIFS. | |
3 | * | |
4 | * Copyright (C) 2006-2008 Nokia Corporation | |
5 | * | |
6 | * This program is free software; you can redistribute it and/or modify it | |
7 | * under the terms of the GNU General Public License version 2 as published by | |
8 | * the Free Software Foundation. | |
9 | * | |
10 | * This program is distributed in the hope that it will be useful, but WITHOUT | |
11 | * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or | |
12 | * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for | |
13 | * more details. | |
14 | * | |
15 | * You should have received a copy of the GNU General Public License along with | |
16 | * this program; if not, write to the Free Software Foundation, Inc., 51 | |
17 | * Franklin St, Fifth Floor, Boston, MA 02110-1301 USA | |
18 | * | |
19 | * Authors: Artem Bityutskiy (Битюцкий Артём) | |
20 | * Adrian Hunter | |
21 | */ | |
22 | ||
23 | /* | |
24 | * This file contains miscellaneous helper functions. | |
25 | */ | |
26 | ||
27 | #ifndef __UBIFS_MISC_H__ | |
28 | #define __UBIFS_MISC_H__ | |
29 | ||
30 | /** | |
31 | * ubifs_zn_dirty - check if znode is dirty. | |
32 | * @znode: znode to check | |
33 | * | |
34 | * This helper function returns %1 if @znode is dirty and %0 otherwise. | |
35 | */ | |
36 | static inline int ubifs_zn_dirty(const struct ubifs_znode *znode) | |
37 | { | |
38 | return !!test_bit(DIRTY_ZNODE, &znode->flags); | |
39 | } | |
40 | ||
41 | /** | |
42 | * ubifs_wake_up_bgt - wake up background thread. | |
43 | * @c: UBIFS file-system description object | |
44 | */ | |
45 | static inline void ubifs_wake_up_bgt(struct ubifs_info *c) | |
46 | { | |
47 | if (c->bgt && !c->need_bgt) { | |
48 | c->need_bgt = 1; | |
49 | wake_up_process(c->bgt); | |
50 | } | |
51 | } | |
52 | ||
53 | /** | |
54 | * ubifs_tnc_find_child - find next child in znode. | |
55 | * @znode: znode to search at | |
56 | * @start: the zbranch index to start at | |
57 | * | |
58 | * This helper function looks for znode child starting at index @start. Returns | |
59 | * the child or %NULL if no children were found. | |
60 | */ | |
61 | static inline struct ubifs_znode * | |
62 | ubifs_tnc_find_child(struct ubifs_znode *znode, int start) | |
63 | { | |
64 | while (start < znode->child_cnt) { | |
65 | if (znode->zbranch[start].znode) | |
66 | return znode->zbranch[start].znode; | |
67 | start += 1; | |
68 | } | |
69 | ||
70 | return NULL; | |
71 | } | |
72 | ||
73 | /** | |
74 | * ubifs_inode - get UBIFS inode information by VFS 'struct inode' object. | |
75 | * @inode: the VFS 'struct inode' pointer | |
76 | */ | |
77 | static inline struct ubifs_inode *ubifs_inode(const struct inode *inode) | |
78 | { | |
79 | return container_of(inode, struct ubifs_inode, vfs_inode); | |
80 | } | |
81 | ||
1e51764a AB |
82 | /** |
83 | * ubifs_compr_present - check if compressor was compiled in. | |
84 | * @compr_type: compressor type to check | |
85 | * | |
86 | * This function returns %1 of compressor of type @compr_type is present, and | |
87 | * %0 if not. | |
88 | */ | |
89 | static inline int ubifs_compr_present(int compr_type) | |
90 | { | |
91 | ubifs_assert(compr_type >= 0 && compr_type < UBIFS_COMPR_TYPES_CNT); | |
92 | return !!ubifs_compressors[compr_type]->capi_name; | |
93 | } | |
94 | ||
95 | /** | |
96 | * ubifs_compr_name - get compressor name string by its type. | |
97 | * @compr_type: compressor type | |
98 | * | |
99 | * This function returns compressor type string. | |
100 | */ | |
101 | static inline const char *ubifs_compr_name(int compr_type) | |
102 | { | |
103 | ubifs_assert(compr_type >= 0 && compr_type < UBIFS_COMPR_TYPES_CNT); | |
104 | return ubifs_compressors[compr_type]->name; | |
105 | } | |
106 | ||
107 | /** | |
108 | * ubifs_wbuf_sync - synchronize write-buffer. | |
109 | * @wbuf: write-buffer to synchronize | |
110 | * | |
111 | * This is the same as as 'ubifs_wbuf_sync_nolock()' but it does not assume | |
112 | * that the write-buffer is already locked. | |
113 | */ | |
114 | static inline int ubifs_wbuf_sync(struct ubifs_wbuf *wbuf) | |
115 | { | |
116 | int err; | |
117 | ||
118 | mutex_lock_nested(&wbuf->io_mutex, wbuf->jhead); | |
119 | err = ubifs_wbuf_sync_nolock(wbuf); | |
120 | mutex_unlock(&wbuf->io_mutex); | |
121 | return err; | |
122 | } | |
123 | ||
124 | /** | |
125 | * ubifs_leb_unmap - unmap an LEB. | |
126 | * @c: UBIFS file-system description object | |
127 | * @lnum: LEB number to unmap | |
128 | * | |
129 | * This function returns %0 on success and a negative error code on failure. | |
130 | */ | |
131 | static inline int ubifs_leb_unmap(const struct ubifs_info *c, int lnum) | |
132 | { | |
133 | int err; | |
134 | ||
135 | if (c->ro_media) | |
136 | return -EROFS; | |
137 | err = ubi_leb_unmap(c->ubi, lnum); | |
138 | if (err) { | |
139 | ubifs_err("unmap LEB %d failed, error %d", lnum, err); | |
140 | return err; | |
141 | } | |
142 | ||
143 | return 0; | |
144 | } | |
145 | ||
146 | /** | |
147 | * ubifs_leb_write - write to a LEB. | |
148 | * @c: UBIFS file-system description object | |
149 | * @lnum: LEB number to write | |
150 | * @buf: buffer to write from | |
151 | * @offs: offset within LEB to write to | |
152 | * @len: length to write | |
153 | * @dtype: data type | |
154 | * | |
155 | * This function returns %0 on success and a negative error code on failure. | |
156 | */ | |
157 | static inline int ubifs_leb_write(const struct ubifs_info *c, int lnum, | |
158 | const void *buf, int offs, int len, int dtype) | |
159 | { | |
160 | int err; | |
161 | ||
162 | if (c->ro_media) | |
163 | return -EROFS; | |
164 | err = ubi_leb_write(c->ubi, lnum, buf, offs, len, dtype); | |
165 | if (err) { | |
166 | ubifs_err("writing %d bytes at %d:%d, error %d", | |
167 | len, lnum, offs, err); | |
168 | return err; | |
169 | } | |
170 | ||
171 | return 0; | |
172 | } | |
173 | ||
174 | /** | |
175 | * ubifs_leb_change - atomic LEB change. | |
176 | * @c: UBIFS file-system description object | |
177 | * @lnum: LEB number to write | |
178 | * @buf: buffer to write from | |
179 | * @len: length to write | |
180 | * @dtype: data type | |
181 | * | |
182 | * This function returns %0 on success and a negative error code on failure. | |
183 | */ | |
184 | static inline int ubifs_leb_change(const struct ubifs_info *c, int lnum, | |
185 | const void *buf, int len, int dtype) | |
186 | { | |
187 | int err; | |
188 | ||
189 | if (c->ro_media) | |
190 | return -EROFS; | |
191 | err = ubi_leb_change(c->ubi, lnum, buf, len, dtype); | |
192 | if (err) { | |
193 | ubifs_err("changing %d bytes in LEB %d, error %d", | |
194 | len, lnum, err); | |
195 | return err; | |
196 | } | |
197 | ||
198 | return 0; | |
199 | } | |
200 | ||
201 | /** | |
202 | * ubifs_encode_dev - encode device node IDs. | |
203 | * @dev: UBIFS device node information | |
204 | * @rdev: device IDs to encode | |
205 | * | |
206 | * This is a helper function which encodes major/minor numbers of a device node | |
207 | * into UBIFS device node description. We use standard Linux "new" and "huge" | |
208 | * encodings. | |
209 | */ | |
210 | static inline int ubifs_encode_dev(union ubifs_dev_desc *dev, dev_t rdev) | |
211 | { | |
212 | if (new_valid_dev(rdev)) { | |
213 | dev->new = cpu_to_le32(new_encode_dev(rdev)); | |
214 | return sizeof(dev->new); | |
215 | } else { | |
216 | dev->huge = cpu_to_le64(huge_encode_dev(rdev)); | |
217 | return sizeof(dev->huge); | |
218 | } | |
219 | } | |
220 | ||
221 | /** | |
222 | * ubifs_add_dirt - add dirty space to LEB properties. | |
223 | * @c: the UBIFS file-system description object | |
224 | * @lnum: LEB to add dirty space for | |
225 | * @dirty: dirty space to add | |
226 | * | |
227 | * This is a helper function which increased amount of dirty LEB space. Returns | |
228 | * zero in case of success and a negative error code in case of failure. | |
229 | */ | |
230 | static inline int ubifs_add_dirt(struct ubifs_info *c, int lnum, int dirty) | |
231 | { | |
232 | return ubifs_update_one_lp(c, lnum, LPROPS_NC, dirty, 0, 0); | |
233 | } | |
234 | ||
235 | /** | |
236 | * ubifs_return_leb - return LEB to lprops. | |
237 | * @c: the UBIFS file-system description object | |
238 | * @lnum: LEB to return | |
239 | * | |
240 | * This helper function cleans the "taken" flag of a logical eraseblock in the | |
241 | * lprops. Returns zero in case of success and a negative error code in case of | |
242 | * failure. | |
243 | */ | |
244 | static inline int ubifs_return_leb(struct ubifs_info *c, int lnum) | |
245 | { | |
246 | return ubifs_change_one_lp(c, lnum, LPROPS_NC, LPROPS_NC, 0, | |
247 | LPROPS_TAKEN, 0); | |
248 | } | |
249 | ||
250 | /** | |
251 | * ubifs_idx_node_sz - return index node size. | |
252 | * @c: the UBIFS file-system description object | |
253 | * @child_cnt: number of children of this index node | |
254 | */ | |
255 | static inline int ubifs_idx_node_sz(const struct ubifs_info *c, int child_cnt) | |
256 | { | |
257 | return UBIFS_IDX_NODE_SZ + (UBIFS_BRANCH_SZ + c->key_len) * child_cnt; | |
258 | } | |
259 | ||
260 | /** | |
261 | * ubifs_idx_branch - return pointer to an index branch. | |
262 | * @c: the UBIFS file-system description object | |
263 | * @idx: index node | |
264 | * @bnum: branch number | |
265 | */ | |
266 | static inline | |
267 | struct ubifs_branch *ubifs_idx_branch(const struct ubifs_info *c, | |
268 | const struct ubifs_idx_node *idx, | |
269 | int bnum) | |
270 | { | |
271 | return (struct ubifs_branch *)((void *)idx->branches + | |
272 | (UBIFS_BRANCH_SZ + c->key_len) * bnum); | |
273 | } | |
274 | ||
275 | /** | |
276 | * ubifs_idx_key - return pointer to an index key. | |
277 | * @c: the UBIFS file-system description object | |
278 | * @idx: index node | |
279 | */ | |
280 | static inline void *ubifs_idx_key(const struct ubifs_info *c, | |
281 | const struct ubifs_idx_node *idx) | |
282 | { | |
283 | return (void *)((struct ubifs_branch *)idx->branches)->key; | |
284 | } | |
285 | ||
1e51764a AB |
286 | /** |
287 | * ubifs_current_time - round current time to time granularity. | |
288 | * @inode: inode | |
289 | */ | |
290 | static inline struct timespec ubifs_current_time(struct inode *inode) | |
291 | { | |
292 | return (inode->i_sb->s_time_gran < NSEC_PER_SEC) ? | |
293 | current_fs_time(inode->i_sb) : CURRENT_TIME_SEC; | |
294 | } | |
295 | ||
601c0bc4 AH |
296 | /** |
297 | * ubifs_tnc_lookup - look up a file-system node. | |
298 | * @c: UBIFS file-system description object | |
299 | * @key: node key to lookup | |
300 | * @node: the node is returned here | |
301 | * | |
302 | * This function look up and reads node with key @key. The caller has to make | |
303 | * sure the @node buffer is large enough to fit the node. Returns zero in case | |
304 | * of success, %-ENOENT if the node was not found, and a negative error code in | |
305 | * case of failure. | |
306 | */ | |
307 | static inline int ubifs_tnc_lookup(struct ubifs_info *c, | |
308 | const union ubifs_key *key, void *node) | |
309 | { | |
310 | return ubifs_tnc_locate(c, key, node, NULL, NULL); | |
311 | } | |
312 | ||
1e51764a | 313 | #endif /* __UBIFS_MISC_H__ */ |