blob: 84bf0fd4a4f1e24a3ff70f0e8de32fb514feb6e1 [file] [log] [blame]
Linus Torvalds1da177e2005-04-16 15:20:36 -07001/*
2 * misc.c
3 *
4 * PURPOSE
5 * Miscellaneous routines for the OSTA-UDF(tm) filesystem.
6 *
Linus Torvalds1da177e2005-04-16 15:20:36 -07007 * COPYRIGHT
8 * This file is distributed under the terms of the GNU General Public
9 * License (GPL). Copies of the GPL can be obtained from:
10 * ftp://prep.ai.mit.edu/pub/gnu/GPL
11 * Each contributing author retains all rights to their own work.
12 *
13 * (C) 1998 Dave Boynton
14 * (C) 1998-2004 Ben Fennema
15 * (C) 1999-2000 Stelias Computing Inc
16 *
17 * HISTORY
18 *
19 * 04/19/99 blf partial support for reading/writing specific EA's
20 */
21
22#include "udfdecl.h"
23
24#include <linux/fs.h>
25#include <linux/string.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070026#include <linux/buffer_head.h>
Bob Copelandf845fce2008-04-17 09:47:48 +020027#include <linux/crc-itu-t.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070028
29#include "udf_i.h"
30#include "udf_sb.h"
31
Cyrill Gorcunovcb00ea32007-07-19 01:47:43 -070032struct buffer_head *udf_tgetblk(struct super_block *sb, int block)
Linus Torvalds1da177e2005-04-16 15:20:36 -070033{
34 if (UDF_QUERY_FLAG(sb, UDF_FLAG_VARCONV))
35 return sb_getblk(sb, udf_fixed_to_variable(block));
36 else
37 return sb_getblk(sb, block);
38}
39
Cyrill Gorcunovcb00ea32007-07-19 01:47:43 -070040struct buffer_head *udf_tread(struct super_block *sb, int block)
Linus Torvalds1da177e2005-04-16 15:20:36 -070041{
42 if (UDF_QUERY_FLAG(sb, UDF_FLAG_VARCONV))
43 return sb_bread(sb, udf_fixed_to_variable(block));
44 else
45 return sb_bread(sb, block);
46}
47
Cyrill Gorcunovcb00ea32007-07-19 01:47:43 -070048struct genericFormat *udf_add_extendedattr(struct inode *inode, uint32_t size,
49 uint32_t type, uint8_t loc)
Linus Torvalds1da177e2005-04-16 15:20:36 -070050{
51 uint8_t *ea = NULL, *ad = NULL;
52 int offset;
53 uint16_t crclen;
Marcin Slusarz48d6d8f2008-02-08 04:20:44 -080054 struct udf_inode_info *iinfo = UDF_I(inode);
Linus Torvalds1da177e2005-04-16 15:20:36 -070055
Marcin Slusarz48d6d8f2008-02-08 04:20:44 -080056 ea = iinfo->i_ext.i_data;
57 if (iinfo->i_lenEAttr) {
58 ad = iinfo->i_ext.i_data + iinfo->i_lenEAttr;
Cyrill Gorcunov28de7942007-07-21 04:37:18 -070059 } else {
Linus Torvalds1da177e2005-04-16 15:20:36 -070060 ad = ea;
61 size += sizeof(struct extendedAttrHeaderDesc);
62 }
63
64 offset = inode->i_sb->s_blocksize - udf_file_entry_alloc_offset(inode) -
Marcin Slusarz48d6d8f2008-02-08 04:20:44 -080065 iinfo->i_lenAlloc;
Linus Torvalds1da177e2005-04-16 15:20:36 -070066
67 /* TODO - Check for FreeEASpace */
68
Cyrill Gorcunovcb00ea32007-07-19 01:47:43 -070069 if (loc & 0x01 && offset >= size) {
Linus Torvalds1da177e2005-04-16 15:20:36 -070070 struct extendedAttrHeaderDesc *eahd;
71 eahd = (struct extendedAttrHeaderDesc *)ea;
72
Marcin Slusarz48d6d8f2008-02-08 04:20:44 -080073 if (iinfo->i_lenAlloc)
74 memmove(&ad[size], ad, iinfo->i_lenAlloc);
Linus Torvalds1da177e2005-04-16 15:20:36 -070075
Marcin Slusarz48d6d8f2008-02-08 04:20:44 -080076 if (iinfo->i_lenEAttr) {
Linus Torvalds1da177e2005-04-16 15:20:36 -070077 /* check checksum/crc */
Marcin Slusarz5e0f0012008-02-08 04:20:41 -080078 if (eahd->descTag.tagIdent !=
79 cpu_to_le16(TAG_IDENT_EAHD) ||
Marcin Slusarz4b111112008-02-08 04:20:36 -080080 le32_to_cpu(eahd->descTag.tagLocation) !=
Marcin Slusarz48d6d8f2008-02-08 04:20:44 -080081 iinfo->i_location.logicalBlockNum)
Linus Torvalds1da177e2005-04-16 15:20:36 -070082 return NULL;
Cyrill Gorcunovcb00ea32007-07-19 01:47:43 -070083 } else {
Marcin Slusarz6c79e982008-02-08 04:20:30 -080084 struct udf_sb_info *sbi = UDF_SB(inode->i_sb);
85
Linus Torvalds1da177e2005-04-16 15:20:36 -070086 size -= sizeof(struct extendedAttrHeaderDesc);
Marcin Slusarz48d6d8f2008-02-08 04:20:44 -080087 iinfo->i_lenEAttr +=
Marcin Slusarz4b111112008-02-08 04:20:36 -080088 sizeof(struct extendedAttrHeaderDesc);
Linus Torvalds1da177e2005-04-16 15:20:36 -070089 eahd->descTag.tagIdent = cpu_to_le16(TAG_IDENT_EAHD);
Marcin Slusarz6c79e982008-02-08 04:20:30 -080090 if (sbi->s_udfrev >= 0x0200)
Linus Torvalds1da177e2005-04-16 15:20:36 -070091 eahd->descTag.descVersion = cpu_to_le16(3);
92 else
93 eahd->descTag.descVersion = cpu_to_le16(2);
Marcin Slusarz4b111112008-02-08 04:20:36 -080094 eahd->descTag.tagSerialNum =
95 cpu_to_le16(sbi->s_serial_number);
96 eahd->descTag.tagLocation = cpu_to_le32(
Marcin Slusarz48d6d8f2008-02-08 04:20:44 -080097 iinfo->i_location.logicalBlockNum);
Linus Torvalds1da177e2005-04-16 15:20:36 -070098 eahd->impAttrLocation = cpu_to_le32(0xFFFFFFFF);
99 eahd->appAttrLocation = cpu_to_le32(0xFFFFFFFF);
100 }
101
Marcin Slusarz48d6d8f2008-02-08 04:20:44 -0800102 offset = iinfo->i_lenEAttr;
Cyrill Gorcunovcb00ea32007-07-19 01:47:43 -0700103 if (type < 2048) {
Marcin Slusarz4b111112008-02-08 04:20:36 -0800104 if (le32_to_cpu(eahd->appAttrLocation) <
Marcin Slusarz48d6d8f2008-02-08 04:20:44 -0800105 iinfo->i_lenEAttr) {
Marcin Slusarz4b111112008-02-08 04:20:36 -0800106 uint32_t aal =
107 le32_to_cpu(eahd->appAttrLocation);
Cyrill Gorcunov28de7942007-07-21 04:37:18 -0700108 memmove(&ea[offset - aal + size],
109 &ea[aal], offset - aal);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700110 offset -= aal;
Marcin Slusarz4b111112008-02-08 04:20:36 -0800111 eahd->appAttrLocation =
112 cpu_to_le32(aal + size);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700113 }
Marcin Slusarz4b111112008-02-08 04:20:36 -0800114 if (le32_to_cpu(eahd->impAttrLocation) <
Marcin Slusarz48d6d8f2008-02-08 04:20:44 -0800115 iinfo->i_lenEAttr) {
Marcin Slusarz4b111112008-02-08 04:20:36 -0800116 uint32_t ial =
117 le32_to_cpu(eahd->impAttrLocation);
Cyrill Gorcunov28de7942007-07-21 04:37:18 -0700118 memmove(&ea[offset - ial + size],
119 &ea[ial], offset - ial);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700120 offset -= ial;
Marcin Slusarz4b111112008-02-08 04:20:36 -0800121 eahd->impAttrLocation =
122 cpu_to_le32(ial + size);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700123 }
Cyrill Gorcunovcb00ea32007-07-19 01:47:43 -0700124 } else if (type < 65536) {
Marcin Slusarz4b111112008-02-08 04:20:36 -0800125 if (le32_to_cpu(eahd->appAttrLocation) <
Marcin Slusarz48d6d8f2008-02-08 04:20:44 -0800126 iinfo->i_lenEAttr) {
Marcin Slusarz4b111112008-02-08 04:20:36 -0800127 uint32_t aal =
128 le32_to_cpu(eahd->appAttrLocation);
Cyrill Gorcunov28de7942007-07-21 04:37:18 -0700129 memmove(&ea[offset - aal + size],
130 &ea[aal], offset - aal);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700131 offset -= aal;
Marcin Slusarz4b111112008-02-08 04:20:36 -0800132 eahd->appAttrLocation =
133 cpu_to_le32(aal + size);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700134 }
135 }
136 /* rewrite CRC + checksum of eahd */
137 crclen = sizeof(struct extendedAttrHeaderDesc) - sizeof(tag);
138 eahd->descTag.descCRCLength = cpu_to_le16(crclen);
Bob Copelandf845fce2008-04-17 09:47:48 +0200139 eahd->descTag.descCRC = cpu_to_le16(crc_itu_t(0, (char *)eahd +
140 sizeof(tag), crclen));
Marcin Slusarz3f2587b2008-02-08 04:20:39 -0800141 eahd->descTag.tagChecksum = udf_tag_checksum(&eahd->descTag);
Marcin Slusarz48d6d8f2008-02-08 04:20:44 -0800142 iinfo->i_lenEAttr += size;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700143 return (struct genericFormat *)&ea[offset];
144 }
Marcin Slusarz4b111112008-02-08 04:20:36 -0800145 if (loc & 0x02)
146 ;
Cyrill Gorcunov28de7942007-07-21 04:37:18 -0700147
Linus Torvalds1da177e2005-04-16 15:20:36 -0700148 return NULL;
149}
150
Cyrill Gorcunovcb00ea32007-07-19 01:47:43 -0700151struct genericFormat *udf_get_extendedattr(struct inode *inode, uint32_t type,
152 uint8_t subtype)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700153{
154 struct genericFormat *gaf;
155 uint8_t *ea = NULL;
156 uint32_t offset;
Marcin Slusarz48d6d8f2008-02-08 04:20:44 -0800157 struct udf_inode_info *iinfo = UDF_I(inode);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700158
Marcin Slusarz48d6d8f2008-02-08 04:20:44 -0800159 ea = iinfo->i_ext.i_data;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700160
Marcin Slusarz48d6d8f2008-02-08 04:20:44 -0800161 if (iinfo->i_lenEAttr) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700162 struct extendedAttrHeaderDesc *eahd;
163 eahd = (struct extendedAttrHeaderDesc *)ea;
164
165 /* check checksum/crc */
Marcin Slusarz5e0f0012008-02-08 04:20:41 -0800166 if (eahd->descTag.tagIdent !=
167 cpu_to_le16(TAG_IDENT_EAHD) ||
Marcin Slusarz4b111112008-02-08 04:20:36 -0800168 le32_to_cpu(eahd->descTag.tagLocation) !=
Marcin Slusarz48d6d8f2008-02-08 04:20:44 -0800169 iinfo->i_location.logicalBlockNum)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700170 return NULL;
Cyrill Gorcunovcb00ea32007-07-19 01:47:43 -0700171
Linus Torvalds1da177e2005-04-16 15:20:36 -0700172 if (type < 2048)
173 offset = sizeof(struct extendedAttrHeaderDesc);
174 else if (type < 65536)
175 offset = le32_to_cpu(eahd->impAttrLocation);
176 else
177 offset = le32_to_cpu(eahd->appAttrLocation);
178
Marcin Slusarz48d6d8f2008-02-08 04:20:44 -0800179 while (offset < iinfo->i_lenEAttr) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700180 gaf = (struct genericFormat *)&ea[offset];
Marcin Slusarz4b111112008-02-08 04:20:36 -0800181 if (le32_to_cpu(gaf->attrType) == type &&
182 gaf->attrSubtype == subtype)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700183 return gaf;
184 else
185 offset += le32_to_cpu(gaf->attrLength);
186 }
187 }
Cyrill Gorcunov28de7942007-07-21 04:37:18 -0700188
Linus Torvalds1da177e2005-04-16 15:20:36 -0700189 return NULL;
190}
191
192/*
193 * udf_read_tagged
194 *
195 * PURPOSE
196 * Read the first block of a tagged descriptor.
197 *
198 * HISTORY
199 * July 1, 1997 - Andrew E. Mileski
200 * Written, tested, and released.
201 */
Cyrill Gorcunovcb00ea32007-07-19 01:47:43 -0700202struct buffer_head *udf_read_tagged(struct super_block *sb, uint32_t block,
Marcin Slusarz4b111112008-02-08 04:20:36 -0800203 uint32_t location, uint16_t *ident)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700204{
205 tag *tag_p;
206 struct buffer_head *bh = NULL;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700207
208 /* Read the block */
209 if (block == 0xFFFFFFFF)
210 return NULL;
211
Sebastian Manciuleaf4bcbbd2008-04-08 14:02:11 +0200212 bh = udf_tread(sb, block);
Cyrill Gorcunovcb00ea32007-07-19 01:47:43 -0700213 if (!bh) {
214 udf_debug("block=%d, location=%d: read failed\n",
Sebastian Manciuleaf4bcbbd2008-04-08 14:02:11 +0200215 block, location);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700216 return NULL;
217 }
218
Cyrill Gorcunov28de7942007-07-21 04:37:18 -0700219 tag_p = (tag *)(bh->b_data);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700220
221 *ident = le16_to_cpu(tag_p->tagIdent);
222
Cyrill Gorcunovcb00ea32007-07-19 01:47:43 -0700223 if (location != le32_to_cpu(tag_p->tagLocation)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700224 udf_debug("location mismatch block %u, tag %u != %u\n",
Sebastian Manciuleaf4bcbbd2008-04-08 14:02:11 +0200225 block, le32_to_cpu(tag_p->tagLocation), location);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700226 goto error_out;
227 }
Cyrill Gorcunovcb00ea32007-07-19 01:47:43 -0700228
Linus Torvalds1da177e2005-04-16 15:20:36 -0700229 /* Verify the tag checksum */
Marcin Slusarz3f2587b2008-02-08 04:20:39 -0800230 if (udf_tag_checksum(tag_p) != tag_p->tagChecksum) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700231 printk(KERN_ERR "udf: tag checksum failed block %d\n", block);
232 goto error_out;
233 }
234
235 /* Verify the tag version */
Marcin Slusarz5e0f0012008-02-08 04:20:41 -0800236 if (tag_p->descVersion != cpu_to_le16(0x0002U) &&
237 tag_p->descVersion != cpu_to_le16(0x0003U)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700238 udf_debug("tag version 0x%04x != 0x0002 || 0x0003 block %d\n",
Cyrill Gorcunovcb00ea32007-07-19 01:47:43 -0700239 le16_to_cpu(tag_p->descVersion), block);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700240 goto error_out;
241 }
242
243 /* Verify the descriptor CRC */
244 if (le16_to_cpu(tag_p->descCRCLength) + sizeof(tag) > sb->s_blocksize ||
Bob Copelandf845fce2008-04-17 09:47:48 +0200245 le16_to_cpu(tag_p->descCRC) == crc_itu_t(0,
246 bh->b_data + sizeof(tag),
247 le16_to_cpu(tag_p->descCRCLength)))
Linus Torvalds1da177e2005-04-16 15:20:36 -0700248 return bh;
Marcin Slusarz4b111112008-02-08 04:20:36 -0800249
Sebastian Manciuleaf4bcbbd2008-04-08 14:02:11 +0200250 udf_debug("Crc failure block %d: crc = %d, crclen = %d\n", block,
251 le16_to_cpu(tag_p->descCRC), le16_to_cpu(tag_p->descCRCLength));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700252
Cyrill Gorcunov28de7942007-07-21 04:37:18 -0700253error_out:
Linus Torvalds1da177e2005-04-16 15:20:36 -0700254 brelse(bh);
255 return NULL;
256}
257
Cyrill Gorcunovcb00ea32007-07-19 01:47:43 -0700258struct buffer_head *udf_read_ptagged(struct super_block *sb, kernel_lb_addr loc,
Marcin Slusarz4b111112008-02-08 04:20:36 -0800259 uint32_t offset, uint16_t *ident)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700260{
261 return udf_read_tagged(sb, udf_get_lb_pblock(sb, loc, offset),
Cyrill Gorcunovcb00ea32007-07-19 01:47:43 -0700262 loc.logicalBlockNum + offset, ident);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700263}
264
Linus Torvalds1da177e2005-04-16 15:20:36 -0700265void udf_update_tag(char *data, int length)
266{
Cyrill Gorcunov28de7942007-07-21 04:37:18 -0700267 tag *tptr = (tag *)data;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700268 length -= sizeof(tag);
269
Linus Torvalds1da177e2005-04-16 15:20:36 -0700270 tptr->descCRCLength = cpu_to_le16(length);
Bob Copelandf845fce2008-04-17 09:47:48 +0200271 tptr->descCRC = cpu_to_le16(crc_itu_t(0, data + sizeof(tag), length));
Marcin Slusarz3f2587b2008-02-08 04:20:39 -0800272 tptr->tagChecksum = udf_tag_checksum(tptr);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700273}
274
275void udf_new_tag(char *data, uint16_t ident, uint16_t version, uint16_t snum,
Cyrill Gorcunovcb00ea32007-07-19 01:47:43 -0700276 uint32_t loc, int length)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700277{
Cyrill Gorcunov28de7942007-07-21 04:37:18 -0700278 tag *tptr = (tag *)data;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700279 tptr->tagIdent = cpu_to_le16(ident);
280 tptr->descVersion = cpu_to_le16(version);
281 tptr->tagSerialNum = cpu_to_le16(snum);
282 tptr->tagLocation = cpu_to_le32(loc);
283 udf_update_tag(data, length);
284}
Marcin Slusarz3f2587b2008-02-08 04:20:39 -0800285
286u8 udf_tag_checksum(const tag *t)
287{
288 u8 *data = (u8 *)t;
289 u8 checksum = 0;
290 int i;
291 for (i = 0; i < sizeof(tag); ++i)
292 if (i != 4) /* position of checksum */
293 checksum += data[i];
294 return checksum;
295}