1 /*
2 * linux/include/linux/hfs_sysdep.h
3 *
4 * Copyright (C) 1996-1997 Paul H. Hargrove
5 * This file may be distributed under the terms of the GNU Public License.
6 *
7 * This file contains constants, types and inline
8 * functions for various system dependent things.
9 *
10 * "XXX" in a comment is a note to myself to consider changing something.
11 *
12 * In function preconditions the term "valid" applied to a pointer to
13 * a structure means that the pointer is non-NULL and the structure it
14 * points to has all fields initialized to consistent values.
15 */
16
17 #ifndef _HFS_SYSDEP_H
18 #define _HFS_SYSDEP_H
19
20 #include <linux/malloc.h>
21 #include <linux/types.h>
22 #include <linux/locks.h>
23 #include <linux/fs.h>
24
25 #include <asm/byteorder.h>
26 #include <asm/unaligned.h>
27
28 extern struct timezone sys_tz;
29
30 #undef offsetof
31 #define offsetof(TYPE, MEMB) ((size_t) &((TYPE *)0)->MEMB)
32
33 /* Typedefs for integer types by size and signedness */
34 typedef __u8 hfs_u8;
35 typedef __u16 hfs_u16;
36 typedef __u32 hfs_u32;
37 typedef __s8 hfs_s8;
38 typedef __s16 hfs_s16;
39 typedef __s32 hfs_s32;
40
41 /* Typedefs for unaligned integer types */
42 typedef unsigned char hfs_byte_t;
43 typedef unsigned char hfs_word_t[2];
44 typedef unsigned char hfs_lword_t[4];
45
46 /* these funny looking things are GCC variable argument macros */
47 #define hfs_warn(format, args...) printk(KERN_WARNING format , ## args)
48 #define hfs_error(format, args...) printk(KERN_ERR format , ## args)
49
50
51 #if defined(DEBUG_ALL) || defined(DEBUG_MEM)
52 extern long int hfs_alloc;
53 #endif
54
55 static inline void *hfs_malloc(unsigned int size) {
56 #if defined(DEBUG_ALL) || defined(DEBUG_MEM)
57 hfs_warn("%ld bytes allocation at %s:%u\n",
58 (hfs_alloc += size), __FILE__, __LINE__);
59 #endif
60 return kmalloc(size, GFP_KERNEL);
61 }
62
63 static inline void hfs_free(void *ptr, unsigned int size) {
64 kfree(ptr);
65 #if defined(DEBUG_ALL) || defined(DEBUG_MEM)
66 hfs_warn("%ld bytes allocation at %s:%u\n",
67 (hfs_alloc -= ptr ? size : 0), __FILE__, __LINE__);
68 #endif
69 }
70
71
72 /* handle conversion between times.
73 *
74 * NOTE: hfs+ doesn't need this. also, we don't use tz_dsttime as that's
75 * not a good thing to do. instead, we depend upon tz_minuteswest
76 * having the correct daylight savings correction.
77 */
78 static inline hfs_u32 hfs_from_utc(hfs_s32 time)
79 {
80 return time - sys_tz.tz_minuteswest*60;
81 }
82
83 static inline hfs_s32 hfs_to_utc(hfs_u32 time)
84 {
85 return time + sys_tz.tz_minuteswest*60;
86 }
87
88 static inline hfs_u32 hfs_time(void) {
89 return htonl(hfs_from_utc(CURRENT_TIME)+2082844800U);
90 }
91
92
93 /*
94 * hfs_wait_queue
95 */
96 typedef wait_queue_head_t hfs_wait_queue;
97
98 static inline void hfs_init_waitqueue(hfs_wait_queue *queue) {
99 init_waitqueue_head(queue);
100 }
101
102 static inline void hfs_sleep_on(hfs_wait_queue *queue) {
103 sleep_on(queue);
104 }
105
106 static inline void hfs_wake_up(hfs_wait_queue *queue) {
107 wake_up(queue);
108 }
109
110 static inline void hfs_relinquish(void) {
111 schedule();
112 }
113
114
115 /*
116 * hfs_sysmdb
117 */
118 typedef struct super_block *hfs_sysmdb;
119
120 static inline void hfs_mdb_dirty(hfs_sysmdb sys_mdb) {
121 sys_mdb->s_dirt = 1;
122 }
123
124 static inline const char *hfs_mdb_name(hfs_sysmdb sys_mdb) {
125 return kdevname(sys_mdb->s_dev);
126 }
127
128
129 /*
130 * hfs_sysentry
131 */
132 typedef struct dentry *hfs_sysentry[4];
133
134 /*
135 * hfs_buffer
136 */
137 typedef struct buffer_head *hfs_buffer;
138
139 #define HFS_BAD_BUFFER NULL
140
141 /* In sysdep.c, since it needs HFS_SECTOR_SIZE */
142 extern hfs_buffer hfs_buffer_get(hfs_sysmdb, int, int);
143
144 static inline int hfs_buffer_ok(hfs_buffer buffer) {
145 return (buffer != NULL);
146 }
147
148 static inline void hfs_buffer_put(hfs_buffer buffer) {
149 brelse(buffer);
150 }
151
152 static inline void hfs_buffer_dirty(hfs_buffer buffer) {
153 mark_buffer_dirty(buffer);
154 }
155
156 static inline void hfs_buffer_sync(hfs_buffer buffer) {
157 while (buffer_locked(buffer)) {
158 wait_on_buffer(buffer);
159 }
160 if (buffer_dirty(buffer)) {
161 ll_rw_block(WRITE, 1, &buffer);
162 wait_on_buffer(buffer);
163 }
164 }
165
166 static inline void *hfs_buffer_data(const hfs_buffer buffer) {
167 return buffer->b_data;
168 }
169
170
171 /*
172 * bit operations
173 */
174
175 #undef BITNR
176 #if defined(__BIG_ENDIAN)
177 # define BITNR(X) ((X)^31)
178 # if !defined(__constant_htonl)
179 # define __constant_htonl(x) (x)
180 # endif
181 # if !defined(__constant_htons)
182 # define __constant_htons(x) (x)
183 # endif
184 #elif defined(__LITTLE_ENDIAN)
185 # define BITNR(X) ((X)^7)
186 # if !defined(__constant_htonl)
187 # define __constant_htonl(x) \
188 ((unsigned long int)((((unsigned long int)(x) & 0x000000ffU) << 24) | \
189 (((unsigned long int)(x) & 0x0000ff00U) << 8) | \
190 (((unsigned long int)(x) & 0x00ff0000U) >> 8) | \
191 (((unsigned long int)(x) & 0xff000000U) >> 24)))
192 # endif
193 # if !defined(__constant_htons)
194 # define __constant_htons(x) \
195 ((unsigned short int)((((unsigned short int)(x) & 0x00ff) << 8) | \
196 (((unsigned short int)(x) & 0xff00) >> 8)))
197 # endif
198 #else
199 # error "Don't know if bytes are big- or little-endian!"
200 #endif
201
202 static inline int hfs_clear_bit(int bitnr, hfs_u32 *lword) {
203 return test_and_clear_bit(BITNR(bitnr), lword);
204 }
205
206 static inline int hfs_set_bit(int bitnr, hfs_u32 *lword) {
207 return test_and_set_bit(BITNR(bitnr), lword);
208 }
209
210 static inline int hfs_test_bit(int bitnr, const hfs_u32 *lword) {
211 /* the kernel should declare the second arg of test_bit as const */
212 return test_bit(BITNR(bitnr), (void *)lword);
213 }
214
215 #undef BITNR
216
217 /*
218 * HFS structures have fields aligned to 16-bit boundaries.
219 * So, 16-bit get/put are easy while 32-bit get/put need
220 * some care on architectures like the DEC Alpha.
221 *
222 * In what follows:
223 * ns = 16-bit integer in network byte-order w/ 16-bit alignment
224 * hs = 16-bit integer in host byte-order w/ 16-bit alignment
225 * nl = 32-bit integer in network byte-order w/ unknown alignment
226 * hl = 32-bit integer in host byte-order w/ unknown alignment
227 * anl = 32-bit integer in network byte-order w/ 32-bit alignment
228 * ahl = 32-bit integer in host byte-order w/ 32-bit alignment
229 * Example: hfs_get_hl() gets an unaligned 32-bit integer converting
230 * it to host byte-order.
231 */
232 #define hfs_get_hs(addr) ntohs(*((hfs_u16 *)(addr)))
233 #define hfs_get_ns(addr) (*((hfs_u16 *)(addr)))
234 #define hfs_get_hl(addr) ntohl(get_unaligned((hfs_u32 *)(addr)))
235 #define hfs_get_nl(addr) get_unaligned((hfs_u32 *)(addr))
236 #define hfs_get_ahl(addr) ntohl(*((hfs_u32 *)(addr)))
237 #define hfs_get_anl(addr) (*((hfs_u32 *)(addr)))
238 #define hfs_put_hs(val, addr) ((void)(*((hfs_u16 *)(addr)) = ntohs(val)))
239 #define hfs_put_ns(val, addr) ((void)(*((hfs_u16 *)(addr)) = (val)))
240 #define hfs_put_hl(val, addr) put_unaligned(htonl(val), (hfs_u32 *)(addr))
241 #define hfs_put_nl(val, addr) put_unaligned((val), (hfs_u32 *)(addr))
242 #define hfs_put_ahl(val, addr) ((void)(*((hfs_u32 *)(addr)) = ntohl(val)))
243 #define hfs_put_anl(val, addr) ((void)(*((hfs_u32 *)(addr)) = (val)))
244
245 #endif
246
This page was automatically generated by the
LXR engine.
Visit the LXR main site for more
information.