2 * linux/fs/adfs/inode.c
4 * Copyright (C) 1997-1999 Russell King
6 * This program is free software; you can redistribute it and/or modify
7 * it under the terms of the GNU General Public License version 2 as
8 * published by the Free Software Foundation.
10 #include <linux/buffer_head.h>
11 #include <linux/writeback.h>
15 * Lookup/Create a block at offset 'block' into 'inode'. We currently do
16 * not support creation of new blocks, so we return -EIO for this case.
19 adfs_get_block(struct inode
*inode
, sector_t block
, struct buffer_head
*bh
,
23 if (block
>= inode
->i_blocks
)
26 block
= __adfs_block_map(inode
->i_sb
, inode
->i_ino
, block
);
28 map_bh(bh
, inode
->i_sb
, block
);
31 /* don't support allocation of blocks yet */
38 static int adfs_writepage(struct page
*page
, struct writeback_control
*wbc
)
40 return block_write_full_page(page
, adfs_get_block
, wbc
);
43 static int adfs_readpage(struct file
*file
, struct page
*page
)
45 return block_read_full_page(page
, adfs_get_block
);
48 static int adfs_write_begin(struct file
*file
, struct address_space
*mapping
,
49 loff_t pos
, unsigned len
, unsigned flags
,
50 struct page
**pagep
, void **fsdata
)
55 ret
= cont_write_begin(file
, mapping
, pos
, len
, flags
, pagep
, fsdata
,
57 &ADFS_I(mapping
->host
)->mmu_private
);
59 loff_t isize
= mapping
->host
->i_size
;
60 if (pos
+ len
> isize
)
61 vmtruncate(mapping
->host
, isize
);
67 static sector_t
_adfs_bmap(struct address_space
*mapping
, sector_t block
)
69 return generic_block_bmap(mapping
, block
, adfs_get_block
);
72 static const struct address_space_operations adfs_aops
= {
73 .readpage
= adfs_readpage
,
74 .writepage
= adfs_writepage
,
75 .sync_page
= block_sync_page
,
76 .write_begin
= adfs_write_begin
,
77 .write_end
= generic_write_end
,
82 * Convert ADFS attributes and filetype to Linux permission.
85 adfs_atts2mode(struct super_block
*sb
, struct inode
*inode
)
87 unsigned int attr
= ADFS_I(inode
)->attr
;
89 struct adfs_sb_info
*asb
= ADFS_SB(sb
);
91 if (attr
& ADFS_NDA_DIRECTORY
) {
92 mode
= S_IRUGO
& asb
->s_owner_mask
;
93 return S_IFDIR
| S_IXUGO
| mode
;
96 switch (ADFS_I(inode
)->filetype
) {
97 case 0xfc0: /* LinkFS */
98 return S_IFLNK
|S_IRWXUGO
;
100 case 0xfe6: /* UnixExec */
101 rmask
= S_IRUGO
| S_IXUGO
;
110 if (attr
& ADFS_NDA_OWNER_READ
)
111 mode
|= rmask
& asb
->s_owner_mask
;
113 if (attr
& ADFS_NDA_OWNER_WRITE
)
114 mode
|= S_IWUGO
& asb
->s_owner_mask
;
116 if (attr
& ADFS_NDA_PUBLIC_READ
)
117 mode
|= rmask
& asb
->s_other_mask
;
119 if (attr
& ADFS_NDA_PUBLIC_WRITE
)
120 mode
|= S_IWUGO
& asb
->s_other_mask
;
125 * Convert Linux permission to ADFS attribute. We try to do the reverse
126 * of atts2mode, but there is not a 1:1 translation.
129 adfs_mode2atts(struct super_block
*sb
, struct inode
*inode
)
133 struct adfs_sb_info
*asb
= ADFS_SB(sb
);
135 /* FIXME: should we be able to alter a link? */
136 if (S_ISLNK(inode
->i_mode
))
137 return ADFS_I(inode
)->attr
;
139 if (S_ISDIR(inode
->i_mode
))
140 attr
= ADFS_NDA_DIRECTORY
;
144 mode
= inode
->i_mode
& asb
->s_owner_mask
;
146 attr
|= ADFS_NDA_OWNER_READ
;
148 attr
|= ADFS_NDA_OWNER_WRITE
;
150 mode
= inode
->i_mode
& asb
->s_other_mask
;
151 mode
&= ~asb
->s_owner_mask
;
153 attr
|= ADFS_NDA_PUBLIC_READ
;
155 attr
|= ADFS_NDA_PUBLIC_WRITE
;
161 * Convert an ADFS time to Unix time. ADFS has a 40-bit centi-second time
162 * referenced to 1 Jan 1900 (til 2248) so we need to discard 2208988800 seconds
163 * of time to convert from RISC OS epoch to Unix epoch.
166 adfs_adfs2unix_time(struct timespec
*tv
, struct inode
*inode
)
168 unsigned int high
, low
;
169 /* 01 Jan 1970 00:00:00 (Unix epoch) as nanoseconds since
170 * 01 Jan 1900 00:00:00 (RISC OS epoch)
172 static const s64 nsec_unix_epoch_diff_risc_os_epoch
=
173 2208988800000000000LL;
176 if (ADFS_I(inode
)->stamped
== 0)
179 high
= ADFS_I(inode
)->loadaddr
& 0xFF; /* top 8 bits of timestamp */
180 low
= ADFS_I(inode
)->execaddr
; /* bottom 32 bits of timestamp */
182 /* convert 40-bit centi-seconds to 32-bit seconds
183 * going via nanoseconds to retain precision
185 nsec
= (((s64
) high
<< 32) | (s64
) low
) * 10000000; /* cs to ns */
187 /* Files dated pre 01 Jan 1970 00:00:00. */
188 if (nsec
< nsec_unix_epoch_diff_risc_os_epoch
)
191 /* convert from RISC OS to Unix epoch */
192 nsec
-= nsec_unix_epoch_diff_risc_os_epoch
;
194 *tv
= ns_to_timespec(nsec
);
202 tv
->tv_sec
= tv
->tv_nsec
= 0;
207 * Convert an Unix time to ADFS time. We only do this if the entry has a
208 * time/date stamp already.
211 adfs_unix2adfs_time(struct inode
*inode
, unsigned int secs
)
213 unsigned int high
, low
;
215 if (ADFS_I(inode
)->stamped
) {
216 /* convert 32-bit seconds to 40-bit centi-seconds */
217 low
= (secs
& 255) * 100;
218 high
= (secs
/ 256) * 100 + (low
>> 8) + 0x336e996a;
220 ADFS_I(inode
)->loadaddr
= (high
>> 24) |
221 (ADFS_I(inode
)->loadaddr
& ~0xff);
222 ADFS_I(inode
)->execaddr
= (low
& 255) | (high
<< 8);
227 * Fill in the inode information from the object information.
229 * Note that this is an inode-less filesystem, so we can't use the inode
230 * number to reference the metadata on the media. Instead, we use the
231 * inode number to hold the object ID, which in turn will tell us where
232 * the data is held. We also save the parent object ID, and with these
233 * two, we can locate the metadata.
235 * This does mean that we rely on an objects parent remaining the same at
236 * all times - we cannot cope with a cross-directory rename (yet).
239 adfs_iget(struct super_block
*sb
, struct object_info
*obj
)
243 inode
= new_inode(sb
);
247 inode
->i_uid
= ADFS_SB(sb
)->s_uid
;
248 inode
->i_gid
= ADFS_SB(sb
)->s_gid
;
249 inode
->i_ino
= obj
->file_id
;
250 inode
->i_size
= obj
->size
;
252 inode
->i_blocks
= (inode
->i_size
+ sb
->s_blocksize
- 1) >>
253 sb
->s_blocksize_bits
;
256 * we need to save the parent directory ID so that
257 * write_inode can update the directory information
258 * for this file. This will need special handling
259 * for cross-directory renames.
261 ADFS_I(inode
)->parent_id
= obj
->parent_id
;
262 ADFS_I(inode
)->loadaddr
= obj
->loadaddr
;
263 ADFS_I(inode
)->execaddr
= obj
->execaddr
;
264 ADFS_I(inode
)->attr
= obj
->attr
;
265 ADFS_I(inode
)->filetype
= obj
->filetype
;
266 ADFS_I(inode
)->stamped
= ((obj
->loadaddr
& 0xfff00000) == 0xfff00000);
268 inode
->i_mode
= adfs_atts2mode(sb
, inode
);
269 adfs_adfs2unix_time(&inode
->i_mtime
, inode
);
270 inode
->i_atime
= inode
->i_mtime
;
271 inode
->i_ctime
= inode
->i_mtime
;
273 if (S_ISDIR(inode
->i_mode
)) {
274 inode
->i_op
= &adfs_dir_inode_operations
;
275 inode
->i_fop
= &adfs_dir_operations
;
276 } else if (S_ISREG(inode
->i_mode
)) {
277 inode
->i_op
= &adfs_file_inode_operations
;
278 inode
->i_fop
= &adfs_file_operations
;
279 inode
->i_mapping
->a_ops
= &adfs_aops
;
280 ADFS_I(inode
)->mmu_private
= inode
->i_size
;
283 insert_inode_hash(inode
);
290 * Validate and convert a changed access mode/time to their ADFS equivalents.
291 * adfs_write_inode will actually write the information back to the directory
295 adfs_notify_change(struct dentry
*dentry
, struct iattr
*attr
)
297 struct inode
*inode
= dentry
->d_inode
;
298 struct super_block
*sb
= inode
->i_sb
;
299 unsigned int ia_valid
= attr
->ia_valid
;
302 error
= inode_change_ok(inode
, attr
);
305 * we can't change the UID or GID of any file -
306 * we have a global UID/GID in the superblock
308 if ((ia_valid
& ATTR_UID
&& attr
->ia_uid
!= ADFS_SB(sb
)->s_uid
) ||
309 (ia_valid
& ATTR_GID
&& attr
->ia_gid
!= ADFS_SB(sb
)->s_gid
))
315 /* XXX: this is missing some actual on-disk truncation.. */
316 if (ia_valid
& ATTR_SIZE
)
317 truncate_setsize(inode
, attr
->ia_size
);
319 if (ia_valid
& ATTR_MTIME
) {
320 inode
->i_mtime
= attr
->ia_mtime
;
321 adfs_unix2adfs_time(inode
, attr
->ia_mtime
.tv_sec
);
324 * FIXME: should we make these == to i_mtime since we don't
325 * have the ability to represent them in our filesystem?
327 if (ia_valid
& ATTR_ATIME
)
328 inode
->i_atime
= attr
->ia_atime
;
329 if (ia_valid
& ATTR_CTIME
)
330 inode
->i_ctime
= attr
->ia_ctime
;
331 if (ia_valid
& ATTR_MODE
) {
332 ADFS_I(inode
)->attr
= adfs_mode2atts(sb
, inode
);
333 inode
->i_mode
= adfs_atts2mode(sb
, inode
);
337 * FIXME: should we be marking this inode dirty even if
338 * we don't have any metadata to write back?
340 if (ia_valid
& (ATTR_SIZE
| ATTR_MTIME
| ATTR_MODE
))
341 mark_inode_dirty(inode
);
347 * write an existing inode back to the directory, and therefore the disk.
348 * The adfs-specific inode data has already been updated by
349 * adfs_notify_change()
351 int adfs_write_inode(struct inode
*inode
, struct writeback_control
*wbc
)
353 struct super_block
*sb
= inode
->i_sb
;
354 struct object_info obj
;
357 obj
.file_id
= inode
->i_ino
;
359 obj
.parent_id
= ADFS_I(inode
)->parent_id
;
360 obj
.loadaddr
= ADFS_I(inode
)->loadaddr
;
361 obj
.execaddr
= ADFS_I(inode
)->execaddr
;
362 obj
.attr
= ADFS_I(inode
)->attr
;
363 obj
.size
= inode
->i_size
;
365 ret
= adfs_dir_update(sb
, &obj
, wbc
->sync_mode
== WB_SYNC_ALL
);