blob: f84bfaa8d941bf2ba6b60793ea34d081c9c2fb2d [file] [log] [blame]
Linus Torvalds1da177e2005-04-16 15:20:36 -07001/*
2 * namei.c
3 *
4 * PURPOSE
5 * Inode name handling 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-2004 Ben Fennema
14 * (C) 1999-2000 Stelias Computing Inc
15 *
16 * HISTORY
17 *
18 * 12/12/98 blf Created. Split out the lookup code from dir.c
19 * 04/19/99 blf link, mknod, symlink support
20 */
21
22#include "udfdecl.h"
23
24#include "udf_i.h"
25#include "udf_sb.h"
26#include <linux/string.h>
27#include <linux/errno.h>
28#include <linux/mm.h>
29#include <linux/slab.h>
30#include <linux/quotaops.h>
31#include <linux/smp_lock.h>
32#include <linux/buffer_head.h>
Alexey Dobriyane8edc6e2007-05-21 01:22:52 +040033#include <linux/sched.h>
Bob Copelandf845fce2008-04-17 09:47:48 +020034#include <linux/crc-itu-t.h>
Rasmus Rohde221e5832008-04-30 17:22:06 +020035#include <linux/exportfs.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070036
Cyrill Gorcunovcb00ea32007-07-19 01:47:43 -070037static inline int udf_match(int len1, const char *name1, int len2,
38 const char *name2)
Linus Torvalds1da177e2005-04-16 15:20:36 -070039{
40 if (len1 != len2)
41 return 0;
Cyrill Gorcunov28de7942007-07-21 04:37:18 -070042
Linus Torvalds1da177e2005-04-16 15:20:36 -070043 return !memcmp(name1, name2, len1);
44}
45
46int udf_write_fi(struct inode *inode, struct fileIdentDesc *cfi,
Cyrill Gorcunovcb00ea32007-07-19 01:47:43 -070047 struct fileIdentDesc *sfi, struct udf_fileident_bh *fibh,
Marcin Slusarz4b111112008-02-08 04:20:36 -080048 uint8_t *impuse, uint8_t *fileident)
Linus Torvalds1da177e2005-04-16 15:20:36 -070049{
50 uint16_t crclen = fibh->eoffset - fibh->soffset - sizeof(tag);
51 uint16_t crc;
Linus Torvalds1da177e2005-04-16 15:20:36 -070052 int offset;
53 uint16_t liu = le16_to_cpu(cfi->lengthOfImpUse);
54 uint8_t lfi = cfi->lengthFileIdent;
55 int padlen = fibh->eoffset - fibh->soffset - liu - lfi -
Cyrill Gorcunov28de7942007-07-21 04:37:18 -070056 sizeof(struct fileIdentDesc);
Linus Torvalds1da177e2005-04-16 15:20:36 -070057 int adinicb = 0;
58
Marcin Slusarzc0b34432008-02-08 04:20:42 -080059 if (UDF_I(inode)->i_alloc_type == ICBTAG_FLAG_AD_IN_ICB)
Linus Torvalds1da177e2005-04-16 15:20:36 -070060 adinicb = 1;
61
62 offset = fibh->soffset + sizeof(struct fileIdentDesc);
63
Cyrill Gorcunovcb00ea32007-07-19 01:47:43 -070064 if (impuse) {
Cyrill Gorcunov28de7942007-07-21 04:37:18 -070065 if (adinicb || (offset + liu < 0)) {
66 memcpy((uint8_t *)sfi->impUse, impuse, liu);
67 } else if (offset >= 0) {
Linus Torvalds1da177e2005-04-16 15:20:36 -070068 memcpy(fibh->ebh->b_data + offset, impuse, liu);
Cyrill Gorcunov28de7942007-07-21 04:37:18 -070069 } else {
70 memcpy((uint8_t *)sfi->impUse, impuse, -offset);
Marcin Slusarz4b111112008-02-08 04:20:36 -080071 memcpy(fibh->ebh->b_data, impuse - offset,
72 liu + offset);
Linus Torvalds1da177e2005-04-16 15:20:36 -070073 }
74 }
75
76 offset += liu;
77
Cyrill Gorcunovcb00ea32007-07-19 01:47:43 -070078 if (fileident) {
Cyrill Gorcunov28de7942007-07-21 04:37:18 -070079 if (adinicb || (offset + lfi < 0)) {
80 memcpy((uint8_t *)sfi->fileIdent + liu, fileident, lfi);
81 } else if (offset >= 0) {
Linus Torvalds1da177e2005-04-16 15:20:36 -070082 memcpy(fibh->ebh->b_data + offset, fileident, lfi);
Cyrill Gorcunov28de7942007-07-21 04:37:18 -070083 } else {
Marcin Slusarz4b111112008-02-08 04:20:36 -080084 memcpy((uint8_t *)sfi->fileIdent + liu, fileident,
85 -offset);
86 memcpy(fibh->ebh->b_data, fileident - offset,
87 lfi + offset);
Linus Torvalds1da177e2005-04-16 15:20:36 -070088 }
89 }
90
91 offset += lfi;
92
Cyrill Gorcunov28de7942007-07-21 04:37:18 -070093 if (adinicb || (offset + padlen < 0)) {
94 memset((uint8_t *)sfi->padding + liu + lfi, 0x00, padlen);
95 } else if (offset >= 0) {
Linus Torvalds1da177e2005-04-16 15:20:36 -070096 memset(fibh->ebh->b_data + offset, 0x00, padlen);
Cyrill Gorcunov28de7942007-07-21 04:37:18 -070097 } else {
98 memset((uint8_t *)sfi->padding + liu + lfi, 0x00, -offset);
Linus Torvalds1da177e2005-04-16 15:20:36 -070099 memset(fibh->ebh->b_data, 0x00, padlen + offset);
100 }
101
Bob Copelandf845fce2008-04-17 09:47:48 +0200102 crc = crc_itu_t(0, (uint8_t *)cfi + sizeof(tag),
103 sizeof(struct fileIdentDesc) - sizeof(tag));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700104
Cyrill Gorcunov28de7942007-07-21 04:37:18 -0700105 if (fibh->sbh == fibh->ebh) {
Bob Copelandf845fce2008-04-17 09:47:48 +0200106 crc = crc_itu_t(crc, (uint8_t *)sfi->impUse,
Marcin Slusarz4b111112008-02-08 04:20:36 -0800107 crclen + sizeof(tag) -
Bob Copelandf845fce2008-04-17 09:47:48 +0200108 sizeof(struct fileIdentDesc));
Cyrill Gorcunov28de7942007-07-21 04:37:18 -0700109 } else if (sizeof(struct fileIdentDesc) >= -fibh->soffset) {
Bob Copelandf845fce2008-04-17 09:47:48 +0200110 crc = crc_itu_t(crc, fibh->ebh->b_data +
Marcin Slusarz4b111112008-02-08 04:20:36 -0800111 sizeof(struct fileIdentDesc) +
112 fibh->soffset,
113 crclen + sizeof(tag) -
Bob Copelandf845fce2008-04-17 09:47:48 +0200114 sizeof(struct fileIdentDesc));
Cyrill Gorcunov28de7942007-07-21 04:37:18 -0700115 } else {
Bob Copelandf845fce2008-04-17 09:47:48 +0200116 crc = crc_itu_t(crc, (uint8_t *)sfi->impUse,
117 -fibh->soffset - sizeof(struct fileIdentDesc));
118 crc = crc_itu_t(crc, fibh->ebh->b_data, fibh->eoffset);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700119 }
120
121 cfi->descTag.descCRC = cpu_to_le16(crc);
122 cfi->descTag.descCRCLength = cpu_to_le16(crclen);
Marcin Slusarz3f2587b2008-02-08 04:20:39 -0800123 cfi->descTag.tagChecksum = udf_tag_checksum(&cfi->descTag);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700124
Cyrill Gorcunov28de7942007-07-21 04:37:18 -0700125 if (adinicb || (sizeof(struct fileIdentDesc) <= -fibh->soffset)) {
Marcin Slusarz4b111112008-02-08 04:20:36 -0800126 memcpy((uint8_t *)sfi, (uint8_t *)cfi,
127 sizeof(struct fileIdentDesc));
Cyrill Gorcunov28de7942007-07-21 04:37:18 -0700128 } else {
129 memcpy((uint8_t *)sfi, (uint8_t *)cfi, -fibh->soffset);
130 memcpy(fibh->ebh->b_data, (uint8_t *)cfi - fibh->soffset,
Cyrill Gorcunovcb00ea32007-07-19 01:47:43 -0700131 sizeof(struct fileIdentDesc) + fibh->soffset);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700132 }
133
Cyrill Gorcunov28de7942007-07-21 04:37:18 -0700134 if (adinicb) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700135 mark_inode_dirty(inode);
Cyrill Gorcunov28de7942007-07-21 04:37:18 -0700136 } else {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700137 if (fibh->sbh != fibh->ebh)
138 mark_buffer_dirty_inode(fibh->ebh, inode);
139 mark_buffer_dirty_inode(fibh->sbh, inode);
140 }
141 return 0;
142}
143
Cyrill Gorcunovcb00ea32007-07-19 01:47:43 -0700144static struct fileIdentDesc *udf_find_entry(struct inode *dir,
Al Viro9fbb76c2008-10-12 00:15:17 -0400145 struct qstr *child,
Cyrill Gorcunovcb00ea32007-07-19 01:47:43 -0700146 struct udf_fileident_bh *fibh,
147 struct fileIdentDesc *cfi)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700148{
Cyrill Gorcunovcb00ea32007-07-19 01:47:43 -0700149 struct fileIdentDesc *fi = NULL;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700150 loff_t f_pos;
151 int block, flen;
Jan Karab80697c2008-03-04 14:14:05 +0100152 char *fname = NULL;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700153 char *nameptr;
154 uint8_t lfi;
155 uint16_t liu;
KAMBAROV, ZAURec471dc2005-06-28 20:45:10 -0700156 loff_t size;
Jan Karaff116fc2007-05-08 00:35:14 -0700157 kernel_lb_addr eloc;
158 uint32_t elen;
Jan Kara60448b12007-05-08 00:35:13 -0700159 sector_t offset;
Cyrill Gorcunov28de7942007-07-21 04:37:18 -0700160 struct extent_position epos = {};
Marcin Slusarz48d6d8f2008-02-08 04:20:44 -0800161 struct udf_inode_info *dinfo = UDF_I(dir);
Al Viro9fbb76c2008-10-12 00:15:17 -0400162 int isdotdot = child->len == 2 &&
163 child->name[0] == '.' && child->name[1] == '.';
Linus Torvalds1da177e2005-04-16 15:20:36 -0700164
Jan Karaaf793292008-02-08 04:20:50 -0800165 size = udf_ext0_offset(dir) + dir->i_size;
166 f_pos = udf_ext0_offset(dir);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700167
Jan Karab80697c2008-03-04 14:14:05 +0100168 fibh->sbh = fibh->ebh = NULL;
Jan Karaaf793292008-02-08 04:20:50 -0800169 fibh->soffset = fibh->eoffset = f_pos & (dir->i_sb->s_blocksize - 1);
Jan Karab80697c2008-03-04 14:14:05 +0100170 if (dinfo->i_alloc_type != ICBTAG_FLAG_AD_IN_ICB) {
171 if (inode_bmap(dir, f_pos >> dir->i_sb->s_blocksize_bits, &epos,
172 &eloc, &elen, &offset) != (EXT_RECORDED_ALLOCATED >> 30))
173 goto out_err;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700174 block = udf_get_lb_pblock(dir->i_sb, eloc, offset);
Cyrill Gorcunovcb00ea32007-07-19 01:47:43 -0700175 if ((++offset << dir->i_sb->s_blocksize_bits) < elen) {
Marcin Slusarz48d6d8f2008-02-08 04:20:44 -0800176 if (dinfo->i_alloc_type == ICBTAG_FLAG_AD_SHORT)
Jan Karaff116fc2007-05-08 00:35:14 -0700177 epos.offset -= sizeof(short_ad);
Marcin Slusarz48d6d8f2008-02-08 04:20:44 -0800178 else if (dinfo->i_alloc_type == ICBTAG_FLAG_AD_LONG)
Jan Karaff116fc2007-05-08 00:35:14 -0700179 epos.offset -= sizeof(long_ad);
Marcin Slusarz4b111112008-02-08 04:20:36 -0800180 } else
Linus Torvalds1da177e2005-04-16 15:20:36 -0700181 offset = 0;
182
Marcin Slusarz4b111112008-02-08 04:20:36 -0800183 fibh->sbh = fibh->ebh = udf_tread(dir->i_sb, block);
Jan Karab80697c2008-03-04 14:14:05 +0100184 if (!fibh->sbh)
185 goto out_err;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700186 }
187
Jan Karab80697c2008-03-04 14:14:05 +0100188 fname = kmalloc(UDF_NAME_LEN, GFP_NOFS);
189 if (!fname)
190 goto out_err;
191
Jan Karaaf793292008-02-08 04:20:50 -0800192 while (f_pos < size) {
Cyrill Gorcunovcb00ea32007-07-19 01:47:43 -0700193 fi = udf_fileident_read(dir, &f_pos, fibh, cfi, &epos, &eloc,
194 &elen, &offset);
Jan Karab80697c2008-03-04 14:14:05 +0100195 if (!fi)
196 goto out_err;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700197
198 liu = le16_to_cpu(cfi->lengthOfImpUse);
199 lfi = cfi->lengthFileIdent;
200
Cyrill Gorcunovcb00ea32007-07-19 01:47:43 -0700201 if (fibh->sbh == fibh->ebh) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700202 nameptr = fi->fileIdent + liu;
Cyrill Gorcunovcb00ea32007-07-19 01:47:43 -0700203 } else {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700204 int poffset; /* Unpaded ending offset */
205
Marcin Slusarz4b111112008-02-08 04:20:36 -0800206 poffset = fibh->soffset + sizeof(struct fileIdentDesc) +
207 liu + lfi;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700208
Marcin Slusarz4b111112008-02-08 04:20:36 -0800209 if (poffset >= lfi)
210 nameptr = (uint8_t *)(fibh->ebh->b_data +
211 poffset - lfi);
212 else {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700213 nameptr = fname;
Marcin Slusarz4b111112008-02-08 04:20:36 -0800214 memcpy(nameptr, fi->fileIdent + liu,
215 lfi - poffset);
216 memcpy(nameptr + lfi - poffset,
217 fibh->ebh->b_data, poffset);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700218 }
219 }
220
Cyrill Gorcunovcb00ea32007-07-19 01:47:43 -0700221 if ((cfi->fileCharacteristics & FID_FILE_CHAR_DELETED) != 0) {
222 if (!UDF_QUERY_FLAG(dir->i_sb, UDF_FLAG_UNDELETE))
Linus Torvalds1da177e2005-04-16 15:20:36 -0700223 continue;
224 }
Cyrill Gorcunovcb00ea32007-07-19 01:47:43 -0700225
226 if ((cfi->fileCharacteristics & FID_FILE_CHAR_HIDDEN) != 0) {
227 if (!UDF_QUERY_FLAG(dir->i_sb, UDF_FLAG_UNHIDE))
Linus Torvalds1da177e2005-04-16 15:20:36 -0700228 continue;
229 }
230
Rasmus Rohde221e5832008-04-30 17:22:06 +0200231 if ((cfi->fileCharacteristics & FID_FILE_CHAR_PARENT) &&
232 isdotdot) {
233 brelse(epos.bh);
234 return fi;
235 }
236
Linus Torvalds1da177e2005-04-16 15:20:36 -0700237 if (!lfi)
238 continue;
239
Marcin Slusarz4b111112008-02-08 04:20:36 -0800240 flen = udf_get_filename(dir->i_sb, nameptr, fname, lfi);
Al Viro9fbb76c2008-10-12 00:15:17 -0400241 if (flen && udf_match(flen, fname, child->len, child->name))
Jan Karab80697c2008-03-04 14:14:05 +0100242 goto out_ok;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700243 }
Cyrill Gorcunov28de7942007-07-21 04:37:18 -0700244
Jan Karab80697c2008-03-04 14:14:05 +0100245out_err:
246 fi = NULL;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700247 if (fibh->sbh != fibh->ebh)
Jan Kara3bf25cb2007-05-08 00:35:16 -0700248 brelse(fibh->ebh);
249 brelse(fibh->sbh);
Jan Karab80697c2008-03-04 14:14:05 +0100250out_ok:
Jan Kara3bf25cb2007-05-08 00:35:16 -0700251 brelse(epos.bh);
Jan Karab80697c2008-03-04 14:14:05 +0100252 kfree(fname);
Cyrill Gorcunov28de7942007-07-21 04:37:18 -0700253
Jan Karab80697c2008-03-04 14:14:05 +0100254 return fi;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700255}
256
Cyrill Gorcunovcb00ea32007-07-19 01:47:43 -0700257static struct dentry *udf_lookup(struct inode *dir, struct dentry *dentry,
258 struct nameidata *nd)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700259{
260 struct inode *inode = NULL;
Jayachandran Cdb9a3692006-02-03 03:04:50 -0800261 struct fileIdentDesc cfi;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700262 struct udf_fileident_bh fibh;
263
Cyrill Gorcunovcb00ea32007-07-19 01:47:43 -0700264 if (dentry->d_name.len > UDF_NAME_LEN - 2)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700265 return ERR_PTR(-ENAMETOOLONG);
266
267 lock_kernel();
268#ifdef UDF_RECOVERY
269 /* temporary shorthand for specifying files by inode number */
Cyrill Gorcunovcb00ea32007-07-19 01:47:43 -0700270 if (!strncmp(dentry->d_name.name, ".B=", 3)) {
Cyrill Gorcunov28de7942007-07-21 04:37:18 -0700271 kernel_lb_addr lb = {
272 .logicalBlockNum = 0,
Marcin Slusarz4b111112008-02-08 04:20:36 -0800273 .partitionReferenceNum =
274 simple_strtoul(dentry->d_name.name + 3,
275 NULL, 0),
Cyrill Gorcunov28de7942007-07-21 04:37:18 -0700276 };
Linus Torvalds1da177e2005-04-16 15:20:36 -0700277 inode = udf_iget(dir->i_sb, lb);
Cyrill Gorcunovcb00ea32007-07-19 01:47:43 -0700278 if (!inode) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700279 unlock_kernel();
280 return ERR_PTR(-EACCES);
281 }
Marcin Slusarz4b111112008-02-08 04:20:36 -0800282 } else
Cyrill Gorcunov28de7942007-07-21 04:37:18 -0700283#endif /* UDF_RECOVERY */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700284
Al Viro9fbb76c2008-10-12 00:15:17 -0400285 if (udf_find_entry(dir, &dentry->d_name, &fibh, &cfi)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700286 if (fibh.sbh != fibh.ebh)
Jan Kara3bf25cb2007-05-08 00:35:16 -0700287 brelse(fibh.ebh);
288 brelse(fibh.sbh);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700289
290 inode = udf_iget(dir->i_sb, lelb_to_cpu(cfi.icb.extLocation));
Cyrill Gorcunovcb00ea32007-07-19 01:47:43 -0700291 if (!inode) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700292 unlock_kernel();
293 return ERR_PTR(-EACCES);
294 }
295 }
296 unlock_kernel();
Cyrill Gorcunov28de7942007-07-21 04:37:18 -0700297
Rasmus Rohde221e5832008-04-30 17:22:06 +0200298 return d_splice_alias(inode, dentry);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700299}
300
Cyrill Gorcunovcb00ea32007-07-19 01:47:43 -0700301static struct fileIdentDesc *udf_add_entry(struct inode *dir,
302 struct dentry *dentry,
303 struct udf_fileident_bh *fibh,
304 struct fileIdentDesc *cfi, int *err)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700305{
Marcin Slusarz6c79e982008-02-08 04:20:30 -0800306 struct super_block *sb = dir->i_sb;
Cyrill Gorcunovcb00ea32007-07-19 01:47:43 -0700307 struct fileIdentDesc *fi = NULL;
Jan Karab80697c2008-03-04 14:14:05 +0100308 char *name = NULL;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700309 int namelen;
310 loff_t f_pos;
Jan Karaaf793292008-02-08 04:20:50 -0800311 loff_t size = udf_ext0_offset(dir) + dir->i_size;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700312 int nfidlen;
313 uint8_t lfi;
314 uint16_t liu;
315 int block;
Jan Karaff116fc2007-05-08 00:35:14 -0700316 kernel_lb_addr eloc;
Jan Kara9afadc42008-05-06 18:26:17 +0200317 uint32_t elen = 0;
Jan Kara60448b12007-05-08 00:35:13 -0700318 sector_t offset;
Cyrill Gorcunov28de7942007-07-21 04:37:18 -0700319 struct extent_position epos = {};
Marcin Slusarz48d6d8f2008-02-08 04:20:44 -0800320 struct udf_inode_info *dinfo;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700321
Jan Karab80697c2008-03-04 14:14:05 +0100322 fibh->sbh = fibh->ebh = NULL;
323 name = kmalloc(UDF_NAME_LEN, GFP_NOFS);
324 if (!name) {
325 *err = -ENOMEM;
326 goto out_err;
327 }
328
Cyrill Gorcunovcb00ea32007-07-19 01:47:43 -0700329 if (dentry) {
330 if (!dentry->d_name.len) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700331 *err = -EINVAL;
Jan Karab80697c2008-03-04 14:14:05 +0100332 goto out_err;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700333 }
Marcin Slusarz4b111112008-02-08 04:20:36 -0800334 namelen = udf_put_filename(sb, dentry->d_name.name, name,
335 dentry->d_name.len);
336 if (!namelen) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700337 *err = -ENAMETOOLONG;
Jan Karab80697c2008-03-04 14:14:05 +0100338 goto out_err;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700339 }
Cyrill Gorcunov28de7942007-07-21 04:37:18 -0700340 } else {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700341 namelen = 0;
Cyrill Gorcunov28de7942007-07-21 04:37:18 -0700342 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700343
344 nfidlen = (sizeof(struct fileIdentDesc) + namelen + 3) & ~3;
345
Jan Karaaf793292008-02-08 04:20:50 -0800346 f_pos = udf_ext0_offset(dir);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700347
Jan Karaaf793292008-02-08 04:20:50 -0800348 fibh->soffset = fibh->eoffset = f_pos & (dir->i_sb->s_blocksize - 1);
Marcin Slusarz48d6d8f2008-02-08 04:20:44 -0800349 dinfo = UDF_I(dir);
Jan Karab80697c2008-03-04 14:14:05 +0100350 if (dinfo->i_alloc_type != ICBTAG_FLAG_AD_IN_ICB) {
351 if (inode_bmap(dir, f_pos >> dir->i_sb->s_blocksize_bits, &epos,
352 &eloc, &elen, &offset) != (EXT_RECORDED_ALLOCATED >> 30)) {
353 block = udf_get_lb_pblock(dir->i_sb,
354 dinfo->i_location, 0);
355 fibh->soffset = fibh->eoffset = sb->s_blocksize;
356 goto add;
357 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700358 block = udf_get_lb_pblock(dir->i_sb, eloc, offset);
Cyrill Gorcunovcb00ea32007-07-19 01:47:43 -0700359 if ((++offset << dir->i_sb->s_blocksize_bits) < elen) {
Marcin Slusarz48d6d8f2008-02-08 04:20:44 -0800360 if (dinfo->i_alloc_type == ICBTAG_FLAG_AD_SHORT)
Jan Karaff116fc2007-05-08 00:35:14 -0700361 epos.offset -= sizeof(short_ad);
Marcin Slusarz48d6d8f2008-02-08 04:20:44 -0800362 else if (dinfo->i_alloc_type == ICBTAG_FLAG_AD_LONG)
Jan Karaff116fc2007-05-08 00:35:14 -0700363 epos.offset -= sizeof(long_ad);
Marcin Slusarz4b111112008-02-08 04:20:36 -0800364 } else
Linus Torvalds1da177e2005-04-16 15:20:36 -0700365 offset = 0;
366
Marcin Slusarz4b111112008-02-08 04:20:36 -0800367 fibh->sbh = fibh->ebh = udf_tread(dir->i_sb, block);
368 if (!fibh->sbh) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700369 *err = -EIO;
Jan Karab80697c2008-03-04 14:14:05 +0100370 goto out_err;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700371 }
372
Marcin Slusarz48d6d8f2008-02-08 04:20:44 -0800373 block = dinfo->i_location.logicalBlockNum;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700374 }
375
Jan Karaaf793292008-02-08 04:20:50 -0800376 while (f_pos < size) {
Cyrill Gorcunovcb00ea32007-07-19 01:47:43 -0700377 fi = udf_fileident_read(dir, &f_pos, fibh, cfi, &epos, &eloc,
378 &elen, &offset);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700379
Cyrill Gorcunovcb00ea32007-07-19 01:47:43 -0700380 if (!fi) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700381 *err = -EIO;
Jan Karab80697c2008-03-04 14:14:05 +0100382 goto out_err;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700383 }
384
385 liu = le16_to_cpu(cfi->lengthOfImpUse);
386 lfi = cfi->lengthFileIdent;
387
Cyrill Gorcunovcb00ea32007-07-19 01:47:43 -0700388 if ((cfi->fileCharacteristics & FID_FILE_CHAR_DELETED) != 0) {
Marcin Slusarz4b111112008-02-08 04:20:36 -0800389 if (((sizeof(struct fileIdentDesc) +
390 liu + lfi + 3) & ~3) == nfidlen) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700391 cfi->descTag.tagSerialNum = cpu_to_le16(1);
392 cfi->fileVersionNum = cpu_to_le16(1);
393 cfi->fileCharacteristics = 0;
394 cfi->lengthFileIdent = namelen;
395 cfi->lengthOfImpUse = cpu_to_le16(0);
Marcin Slusarz4b111112008-02-08 04:20:36 -0800396 if (!udf_write_fi(dir, cfi, fi, fibh, NULL,
397 name))
Jan Karab80697c2008-03-04 14:14:05 +0100398 goto out_ok;
Marcin Slusarz4b111112008-02-08 04:20:36 -0800399 else {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700400 *err = -EIO;
Jan Karab80697c2008-03-04 14:14:05 +0100401 goto out_err;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700402 }
403 }
404 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700405 }
406
Cyrill Gorcunov28de7942007-07-21 04:37:18 -0700407add:
Jan Kara9afadc42008-05-06 18:26:17 +0200408 /* Is there any extent whose size we need to round up? */
409 if (dinfo->i_alloc_type != ICBTAG_FLAG_AD_IN_ICB && elen) {
Jan Kara05343c42008-02-08 04:20:51 -0800410 elen = (elen + sb->s_blocksize - 1) & ~(sb->s_blocksize - 1);
411 if (dinfo->i_alloc_type == ICBTAG_FLAG_AD_SHORT)
412 epos.offset -= sizeof(short_ad);
413 else if (dinfo->i_alloc_type == ICBTAG_FLAG_AD_LONG)
414 epos.offset -= sizeof(long_ad);
415 udf_write_aext(dir, &epos, eloc, elen, 1);
416 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700417 f_pos += nfidlen;
418
Marcin Slusarz48d6d8f2008-02-08 04:20:44 -0800419 if (dinfo->i_alloc_type == ICBTAG_FLAG_AD_IN_ICB &&
Cyrill Gorcunovcb00ea32007-07-19 01:47:43 -0700420 sb->s_blocksize - fibh->eoffset < nfidlen) {
Jan Kara3bf25cb2007-05-08 00:35:16 -0700421 brelse(epos.bh);
Jan Karaff116fc2007-05-08 00:35:14 -0700422 epos.bh = NULL;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700423 fibh->soffset -= udf_ext0_offset(dir);
424 fibh->eoffset -= udf_ext0_offset(dir);
Jan Karaaf793292008-02-08 04:20:50 -0800425 f_pos -= udf_ext0_offset(dir);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700426 if (fibh->sbh != fibh->ebh)
Jan Kara3bf25cb2007-05-08 00:35:16 -0700427 brelse(fibh->ebh);
428 brelse(fibh->sbh);
Marcin Slusarz4b111112008-02-08 04:20:36 -0800429 fibh->sbh = fibh->ebh =
430 udf_expand_dir_adinicb(dir, &block, err);
431 if (!fibh->sbh)
Jan Karab80697c2008-03-04 14:14:05 +0100432 goto out_err;
Marcin Slusarz48d6d8f2008-02-08 04:20:44 -0800433 epos.block = dinfo->i_location;
Jan Karaff116fc2007-05-08 00:35:14 -0700434 epos.offset = udf_file_entry_alloc_offset(dir);
Jan Kara05343c42008-02-08 04:20:51 -0800435 /* Load extent udf_expand_dir_adinicb() has created */
436 udf_current_aext(dir, &epos, &eloc, &elen, 1);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700437 }
438
Cyrill Gorcunovcb00ea32007-07-19 01:47:43 -0700439 if (sb->s_blocksize - fibh->eoffset >= nfidlen) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700440 fibh->soffset = fibh->eoffset;
441 fibh->eoffset += nfidlen;
Cyrill Gorcunovcb00ea32007-07-19 01:47:43 -0700442 if (fibh->sbh != fibh->ebh) {
Jan Kara3bf25cb2007-05-08 00:35:16 -0700443 brelse(fibh->sbh);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700444 fibh->sbh = fibh->ebh;
445 }
446
Marcin Slusarz48d6d8f2008-02-08 04:20:44 -0800447 if (dinfo->i_alloc_type == ICBTAG_FLAG_AD_IN_ICB) {
448 block = dinfo->i_location.logicalBlockNum;
Marcin Slusarz4b111112008-02-08 04:20:36 -0800449 fi = (struct fileIdentDesc *)
Marcin Slusarz48d6d8f2008-02-08 04:20:44 -0800450 (dinfo->i_ext.i_data +
Marcin Slusarzc0b34432008-02-08 04:20:42 -0800451 fibh->soffset -
Marcin Slusarz4b111112008-02-08 04:20:36 -0800452 udf_ext0_offset(dir) +
Marcin Slusarz48d6d8f2008-02-08 04:20:44 -0800453 dinfo->i_lenEAttr);
Cyrill Gorcunovcb00ea32007-07-19 01:47:43 -0700454 } else {
Marcin Slusarz4b111112008-02-08 04:20:36 -0800455 block = eloc.logicalBlockNum +
456 ((elen - 1) >>
457 dir->i_sb->s_blocksize_bits);
458 fi = (struct fileIdentDesc *)
459 (fibh->sbh->b_data + fibh->soffset);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700460 }
Cyrill Gorcunovcb00ea32007-07-19 01:47:43 -0700461 } else {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700462 fibh->soffset = fibh->eoffset - sb->s_blocksize;
463 fibh->eoffset += nfidlen - sb->s_blocksize;
Cyrill Gorcunovcb00ea32007-07-19 01:47:43 -0700464 if (fibh->sbh != fibh->ebh) {
Jan Kara3bf25cb2007-05-08 00:35:16 -0700465 brelse(fibh->sbh);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700466 fibh->sbh = fibh->ebh;
467 }
468
469 block = eloc.logicalBlockNum + ((elen - 1) >>
Cyrill Gorcunovcb00ea32007-07-19 01:47:43 -0700470 dir->i_sb->s_blocksize_bits);
Marcin Slusarz4b111112008-02-08 04:20:36 -0800471 fibh->ebh = udf_bread(dir,
Jan Karaaf793292008-02-08 04:20:50 -0800472 f_pos >> dir->i_sb->s_blocksize_bits, 1, err);
Jan Karab80697c2008-03-04 14:14:05 +0100473 if (!fibh->ebh)
474 goto out_err;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700475
Cyrill Gorcunov28de7942007-07-21 04:37:18 -0700476 if (!fibh->soffset) {
Jan Karaff116fc2007-05-08 00:35:14 -0700477 if (udf_next_aext(dir, &epos, &eloc, &elen, 1) ==
Cyrill Gorcunovcb00ea32007-07-19 01:47:43 -0700478 (EXT_RECORDED_ALLOCATED >> 30)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700479 block = eloc.logicalBlockNum + ((elen - 1) >>
Cyrill Gorcunov28de7942007-07-21 04:37:18 -0700480 dir->i_sb->s_blocksize_bits);
Marcin Slusarz4b111112008-02-08 04:20:36 -0800481 } else
Cyrill Gorcunovcb00ea32007-07-19 01:47:43 -0700482 block++;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700483
Jan Kara3bf25cb2007-05-08 00:35:16 -0700484 brelse(fibh->sbh);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700485 fibh->sbh = fibh->ebh;
486 fi = (struct fileIdentDesc *)(fibh->sbh->b_data);
Cyrill Gorcunovcb00ea32007-07-19 01:47:43 -0700487 } else {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700488 fi = (struct fileIdentDesc *)
Marcin Slusarz4b111112008-02-08 04:20:36 -0800489 (fibh->sbh->b_data + sb->s_blocksize +
490 fibh->soffset);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700491 }
492 }
493
494 memset(cfi, 0, sizeof(struct fileIdentDesc));
Marcin Slusarz6c79e982008-02-08 04:20:30 -0800495 if (UDF_SB(sb)->s_udfrev >= 0x0200)
Marcin Slusarz4b111112008-02-08 04:20:36 -0800496 udf_new_tag((char *)cfi, TAG_IDENT_FID, 3, 1, block,
497 sizeof(tag));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700498 else
Marcin Slusarz4b111112008-02-08 04:20:36 -0800499 udf_new_tag((char *)cfi, TAG_IDENT_FID, 2, 1, block,
500 sizeof(tag));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700501 cfi->fileVersionNum = cpu_to_le16(1);
502 cfi->lengthFileIdent = namelen;
503 cfi->lengthOfImpUse = cpu_to_le16(0);
Cyrill Gorcunovcb00ea32007-07-19 01:47:43 -0700504 if (!udf_write_fi(dir, cfi, fi, fibh, NULL, name)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700505 dir->i_size += nfidlen;
Marcin Slusarz48d6d8f2008-02-08 04:20:44 -0800506 if (dinfo->i_alloc_type == ICBTAG_FLAG_AD_IN_ICB)
507 dinfo->i_lenAlloc += nfidlen;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700508 mark_inode_dirty(dir);
Jan Karab80697c2008-03-04 14:14:05 +0100509 goto out_ok;
Cyrill Gorcunovcb00ea32007-07-19 01:47:43 -0700510 } else {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700511 *err = -EIO;
Jan Karab80697c2008-03-04 14:14:05 +0100512 goto out_err;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700513 }
Jan Karab80697c2008-03-04 14:14:05 +0100514
515out_err:
516 fi = NULL;
517 if (fibh->sbh != fibh->ebh)
518 brelse(fibh->ebh);
519 brelse(fibh->sbh);
520out_ok:
521 brelse(epos.bh);
522 kfree(name);
523 return fi;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700524}
525
526static int udf_delete_entry(struct inode *inode, struct fileIdentDesc *fi,
Cyrill Gorcunovcb00ea32007-07-19 01:47:43 -0700527 struct udf_fileident_bh *fibh,
528 struct fileIdentDesc *cfi)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700529{
530 cfi->fileCharacteristics |= FID_FILE_CHAR_DELETED;
Cyrill Gorcunov28de7942007-07-21 04:37:18 -0700531
Linus Torvalds1da177e2005-04-16 15:20:36 -0700532 if (UDF_QUERY_FLAG(inode->i_sb, UDF_FLAG_STRICT))
533 memset(&(cfi->icb), 0x00, sizeof(long_ad));
Cyrill Gorcunov28de7942007-07-21 04:37:18 -0700534
Linus Torvalds1da177e2005-04-16 15:20:36 -0700535 return udf_write_fi(inode, cfi, fi, fibh, NULL, NULL);
536}
537
Cyrill Gorcunovcb00ea32007-07-19 01:47:43 -0700538static int udf_create(struct inode *dir, struct dentry *dentry, int mode,
539 struct nameidata *nd)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700540{
541 struct udf_fileident_bh fibh;
542 struct inode *inode;
543 struct fileIdentDesc cfi, *fi;
544 int err;
Marcin Slusarz48d6d8f2008-02-08 04:20:44 -0800545 struct udf_inode_info *iinfo;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700546
547 lock_kernel();
548 inode = udf_new_inode(dir, mode, &err);
Cyrill Gorcunovcb00ea32007-07-19 01:47:43 -0700549 if (!inode) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700550 unlock_kernel();
551 return err;
552 }
553
Marcin Slusarz48d6d8f2008-02-08 04:20:44 -0800554 iinfo = UDF_I(inode);
555 if (iinfo->i_alloc_type == ICBTAG_FLAG_AD_IN_ICB)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700556 inode->i_data.a_ops = &udf_adinicb_aops;
557 else
558 inode->i_data.a_ops = &udf_aops;
559 inode->i_op = &udf_file_inode_operations;
560 inode->i_fop = &udf_file_operations;
561 inode->i_mode = mode;
562 mark_inode_dirty(inode);
563
Marcin Slusarz4b111112008-02-08 04:20:36 -0800564 fi = udf_add_entry(dir, dentry, &fibh, &cfi, &err);
565 if (!fi) {
Cyrill Gorcunovcb00ea32007-07-19 01:47:43 -0700566 inode->i_nlink--;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700567 mark_inode_dirty(inode);
568 iput(inode);
569 unlock_kernel();
570 return err;
571 }
572 cfi.icb.extLength = cpu_to_le32(inode->i_sb->s_blocksize);
Marcin Slusarz48d6d8f2008-02-08 04:20:44 -0800573 cfi.icb.extLocation = cpu_to_lelb(iinfo->i_location);
Cyrill Gorcunov28de7942007-07-21 04:37:18 -0700574 *(__le32 *)((struct allocDescImpUse *)cfi.icb.impUse)->impUse =
Marcin Slusarz48d6d8f2008-02-08 04:20:44 -0800575 cpu_to_le32(iinfo->i_unique & 0x00000000FFFFFFFFUL);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700576 udf_write_fi(dir, &cfi, fi, &fibh, NULL, NULL);
Marcin Slusarzc0b34432008-02-08 04:20:42 -0800577 if (UDF_I(dir)->i_alloc_type == ICBTAG_FLAG_AD_IN_ICB)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700578 mark_inode_dirty(dir);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700579 if (fibh.sbh != fibh.ebh)
Jan Kara3bf25cb2007-05-08 00:35:16 -0700580 brelse(fibh.ebh);
581 brelse(fibh.sbh);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700582 unlock_kernel();
583 d_instantiate(dentry, inode);
Cyrill Gorcunov28de7942007-07-21 04:37:18 -0700584
Linus Torvalds1da177e2005-04-16 15:20:36 -0700585 return 0;
586}
587
Cyrill Gorcunovcb00ea32007-07-19 01:47:43 -0700588static int udf_mknod(struct inode *dir, struct dentry *dentry, int mode,
589 dev_t rdev)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700590{
Cyrill Gorcunovcb00ea32007-07-19 01:47:43 -0700591 struct inode *inode;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700592 struct udf_fileident_bh fibh;
593 struct fileIdentDesc cfi, *fi;
594 int err;
Marcin Slusarz48d6d8f2008-02-08 04:20:44 -0800595 struct udf_inode_info *iinfo;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700596
597 if (!old_valid_dev(rdev))
598 return -EINVAL;
599
600 lock_kernel();
601 err = -EIO;
602 inode = udf_new_inode(dir, mode, &err);
603 if (!inode)
604 goto out;
605
Marcin Slusarz48d6d8f2008-02-08 04:20:44 -0800606 iinfo = UDF_I(inode);
David Howells7706bb32008-11-14 10:39:03 +1100607 inode->i_uid = current_fsuid();
Linus Torvalds1da177e2005-04-16 15:20:36 -0700608 init_special_inode(inode, mode, rdev);
Marcin Slusarz4b111112008-02-08 04:20:36 -0800609 fi = udf_add_entry(dir, dentry, &fibh, &cfi, &err);
610 if (!fi) {
Cyrill Gorcunovcb00ea32007-07-19 01:47:43 -0700611 inode->i_nlink--;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700612 mark_inode_dirty(inode);
613 iput(inode);
614 unlock_kernel();
615 return err;
616 }
617 cfi.icb.extLength = cpu_to_le32(inode->i_sb->s_blocksize);
Marcin Slusarz48d6d8f2008-02-08 04:20:44 -0800618 cfi.icb.extLocation = cpu_to_lelb(iinfo->i_location);
Cyrill Gorcunov28de7942007-07-21 04:37:18 -0700619 *(__le32 *)((struct allocDescImpUse *)cfi.icb.impUse)->impUse =
Marcin Slusarz48d6d8f2008-02-08 04:20:44 -0800620 cpu_to_le32(iinfo->i_unique & 0x00000000FFFFFFFFUL);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700621 udf_write_fi(dir, &cfi, fi, &fibh, NULL, NULL);
Marcin Slusarzc0b34432008-02-08 04:20:42 -0800622 if (UDF_I(dir)->i_alloc_type == ICBTAG_FLAG_AD_IN_ICB)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700623 mark_inode_dirty(dir);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700624 mark_inode_dirty(inode);
625
626 if (fibh.sbh != fibh.ebh)
Jan Kara3bf25cb2007-05-08 00:35:16 -0700627 brelse(fibh.ebh);
628 brelse(fibh.sbh);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700629 d_instantiate(dentry, inode);
630 err = 0;
Cyrill Gorcunov28de7942007-07-21 04:37:18 -0700631
632out:
Linus Torvalds1da177e2005-04-16 15:20:36 -0700633 unlock_kernel();
634 return err;
635}
636
Cyrill Gorcunovcb00ea32007-07-19 01:47:43 -0700637static int udf_mkdir(struct inode *dir, struct dentry *dentry, int mode)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700638{
Cyrill Gorcunovcb00ea32007-07-19 01:47:43 -0700639 struct inode *inode;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700640 struct udf_fileident_bh fibh;
641 struct fileIdentDesc cfi, *fi;
642 int err;
Marcin Slusarz48d6d8f2008-02-08 04:20:44 -0800643 struct udf_inode_info *dinfo = UDF_I(dir);
644 struct udf_inode_info *iinfo;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700645
646 lock_kernel();
647 err = -EMLINK;
Cyrill Gorcunovcb00ea32007-07-19 01:47:43 -0700648 if (dir->i_nlink >= (256 << sizeof(dir->i_nlink)) - 1)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700649 goto out;
650
651 err = -EIO;
652 inode = udf_new_inode(dir, S_IFDIR, &err);
653 if (!inode)
654 goto out;
655
Marcin Slusarz48d6d8f2008-02-08 04:20:44 -0800656 iinfo = UDF_I(inode);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700657 inode->i_op = &udf_dir_inode_operations;
658 inode->i_fop = &udf_dir_operations;
Marcin Slusarz4b111112008-02-08 04:20:36 -0800659 fi = udf_add_entry(inode, NULL, &fibh, &cfi, &err);
660 if (!fi) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700661 inode->i_nlink--;
662 mark_inode_dirty(inode);
663 iput(inode);
664 goto out;
665 }
666 inode->i_nlink = 2;
667 cfi.icb.extLength = cpu_to_le32(inode->i_sb->s_blocksize);
Marcin Slusarz48d6d8f2008-02-08 04:20:44 -0800668 cfi.icb.extLocation = cpu_to_lelb(dinfo->i_location);
Cyrill Gorcunov28de7942007-07-21 04:37:18 -0700669 *(__le32 *)((struct allocDescImpUse *)cfi.icb.impUse)->impUse =
Marcin Slusarz48d6d8f2008-02-08 04:20:44 -0800670 cpu_to_le32(dinfo->i_unique & 0x00000000FFFFFFFFUL);
Marcin Slusarz4b111112008-02-08 04:20:36 -0800671 cfi.fileCharacteristics =
672 FID_FILE_CHAR_DIRECTORY | FID_FILE_CHAR_PARENT;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700673 udf_write_fi(inode, &cfi, fi, &fibh, NULL, NULL);
Jan Kara3bf25cb2007-05-08 00:35:16 -0700674 brelse(fibh.sbh);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700675 inode->i_mode = S_IFDIR | mode;
676 if (dir->i_mode & S_ISGID)
677 inode->i_mode |= S_ISGID;
678 mark_inode_dirty(inode);
679
Marcin Slusarz4b111112008-02-08 04:20:36 -0800680 fi = udf_add_entry(dir, dentry, &fibh, &cfi, &err);
681 if (!fi) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700682 inode->i_nlink = 0;
683 mark_inode_dirty(inode);
684 iput(inode);
685 goto out;
686 }
687 cfi.icb.extLength = cpu_to_le32(inode->i_sb->s_blocksize);
Marcin Slusarz48d6d8f2008-02-08 04:20:44 -0800688 cfi.icb.extLocation = cpu_to_lelb(iinfo->i_location);
Cyrill Gorcunov28de7942007-07-21 04:37:18 -0700689 *(__le32 *)((struct allocDescImpUse *)cfi.icb.impUse)->impUse =
Marcin Slusarz48d6d8f2008-02-08 04:20:44 -0800690 cpu_to_le32(iinfo->i_unique & 0x00000000FFFFFFFFUL);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700691 cfi.fileCharacteristics |= FID_FILE_CHAR_DIRECTORY;
692 udf_write_fi(dir, &cfi, fi, &fibh, NULL, NULL);
Dave Hansend8c76e62006-09-30 23:29:04 -0700693 inc_nlink(dir);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700694 mark_inode_dirty(dir);
695 d_instantiate(dentry, inode);
696 if (fibh.sbh != fibh.ebh)
Jan Kara3bf25cb2007-05-08 00:35:16 -0700697 brelse(fibh.ebh);
698 brelse(fibh.sbh);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700699 err = 0;
Cyrill Gorcunov28de7942007-07-21 04:37:18 -0700700
701out:
Linus Torvalds1da177e2005-04-16 15:20:36 -0700702 unlock_kernel();
703 return err;
704}
705
706static int empty_dir(struct inode *dir)
707{
708 struct fileIdentDesc *fi, cfi;
709 struct udf_fileident_bh fibh;
710 loff_t f_pos;
Jan Karaaf793292008-02-08 04:20:50 -0800711 loff_t size = udf_ext0_offset(dir) + dir->i_size;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700712 int block;
Jan Karaff116fc2007-05-08 00:35:14 -0700713 kernel_lb_addr eloc;
714 uint32_t elen;
Jan Kara60448b12007-05-08 00:35:13 -0700715 sector_t offset;
Cyrill Gorcunov28de7942007-07-21 04:37:18 -0700716 struct extent_position epos = {};
Marcin Slusarz48d6d8f2008-02-08 04:20:44 -0800717 struct udf_inode_info *dinfo = UDF_I(dir);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700718
Jan Karaaf793292008-02-08 04:20:50 -0800719 f_pos = udf_ext0_offset(dir);
720 fibh.soffset = fibh.eoffset = f_pos & (dir->i_sb->s_blocksize - 1);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700721
Marcin Slusarz48d6d8f2008-02-08 04:20:44 -0800722 if (dinfo->i_alloc_type == ICBTAG_FLAG_AD_IN_ICB)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700723 fibh.sbh = fibh.ebh = NULL;
Jan Karaaf793292008-02-08 04:20:50 -0800724 else if (inode_bmap(dir, f_pos >> dir->i_sb->s_blocksize_bits,
Marcin Slusarz4b111112008-02-08 04:20:36 -0800725 &epos, &eloc, &elen, &offset) ==
726 (EXT_RECORDED_ALLOCATED >> 30)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700727 block = udf_get_lb_pblock(dir->i_sb, eloc, offset);
Cyrill Gorcunovcb00ea32007-07-19 01:47:43 -0700728 if ((++offset << dir->i_sb->s_blocksize_bits) < elen) {
Marcin Slusarz48d6d8f2008-02-08 04:20:44 -0800729 if (dinfo->i_alloc_type == ICBTAG_FLAG_AD_SHORT)
Jan Karaff116fc2007-05-08 00:35:14 -0700730 epos.offset -= sizeof(short_ad);
Marcin Slusarz48d6d8f2008-02-08 04:20:44 -0800731 else if (dinfo->i_alloc_type == ICBTAG_FLAG_AD_LONG)
Jan Karaff116fc2007-05-08 00:35:14 -0700732 epos.offset -= sizeof(long_ad);
Marcin Slusarz4b111112008-02-08 04:20:36 -0800733 } else
Linus Torvalds1da177e2005-04-16 15:20:36 -0700734 offset = 0;
735
Marcin Slusarz4b111112008-02-08 04:20:36 -0800736 fibh.sbh = fibh.ebh = udf_tread(dir->i_sb, block);
737 if (!fibh.sbh) {
Jan Kara3bf25cb2007-05-08 00:35:16 -0700738 brelse(epos.bh);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700739 return 0;
740 }
Cyrill Gorcunovcb00ea32007-07-19 01:47:43 -0700741 } else {
Jan Kara3bf25cb2007-05-08 00:35:16 -0700742 brelse(epos.bh);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700743 return 0;
744 }
745
Jan Karaaf793292008-02-08 04:20:50 -0800746 while (f_pos < size) {
Cyrill Gorcunovcb00ea32007-07-19 01:47:43 -0700747 fi = udf_fileident_read(dir, &f_pos, &fibh, &cfi, &epos, &eloc,
748 &elen, &offset);
Cyrill Gorcunovcb00ea32007-07-19 01:47:43 -0700749 if (!fi) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700750 if (fibh.sbh != fibh.ebh)
Jan Kara3bf25cb2007-05-08 00:35:16 -0700751 brelse(fibh.ebh);
752 brelse(fibh.sbh);
753 brelse(epos.bh);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700754 return 0;
755 }
756
Cyrill Gorcunov28de7942007-07-21 04:37:18 -0700757 if (cfi.lengthFileIdent &&
758 (cfi.fileCharacteristics & FID_FILE_CHAR_DELETED) == 0) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700759 if (fibh.sbh != fibh.ebh)
Jan Kara3bf25cb2007-05-08 00:35:16 -0700760 brelse(fibh.ebh);
761 brelse(fibh.sbh);
762 brelse(epos.bh);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700763 return 0;
764 }
765 }
Cyrill Gorcunov28de7942007-07-21 04:37:18 -0700766
Linus Torvalds1da177e2005-04-16 15:20:36 -0700767 if (fibh.sbh != fibh.ebh)
Jan Kara3bf25cb2007-05-08 00:35:16 -0700768 brelse(fibh.ebh);
769 brelse(fibh.sbh);
770 brelse(epos.bh);
Cyrill Gorcunov28de7942007-07-21 04:37:18 -0700771
Linus Torvalds1da177e2005-04-16 15:20:36 -0700772 return 1;
773}
774
Cyrill Gorcunovcb00ea32007-07-19 01:47:43 -0700775static int udf_rmdir(struct inode *dir, struct dentry *dentry)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700776{
777 int retval;
Cyrill Gorcunovcb00ea32007-07-19 01:47:43 -0700778 struct inode *inode = dentry->d_inode;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700779 struct udf_fileident_bh fibh;
780 struct fileIdentDesc *fi, cfi;
781 kernel_lb_addr tloc;
782
783 retval = -ENOENT;
784 lock_kernel();
Al Viro9fbb76c2008-10-12 00:15:17 -0400785 fi = udf_find_entry(dir, &dentry->d_name, &fibh, &cfi);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700786 if (!fi)
787 goto out;
788
789 retval = -EIO;
790 tloc = lelb_to_cpu(cfi.icb.extLocation);
791 if (udf_get_lb_pblock(dir->i_sb, tloc, 0) != inode->i_ino)
792 goto end_rmdir;
793 retval = -ENOTEMPTY;
794 if (!empty_dir(inode))
795 goto end_rmdir;
796 retval = udf_delete_entry(dir, fi, &fibh, &cfi);
797 if (retval)
798 goto end_rmdir;
799 if (inode->i_nlink != 2)
800 udf_warning(inode->i_sb, "udf_rmdir",
Cyrill Gorcunovcb00ea32007-07-19 01:47:43 -0700801 "empty directory has nlink != 2 (%d)",
802 inode->i_nlink);
Dave Hansence71ec32006-09-30 23:29:06 -0700803 clear_nlink(inode);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700804 inode->i_size = 0;
Stephen Mollettc007c062007-05-08 00:31:31 -0700805 inode_dec_link_count(dir);
Marcin Slusarz4b111112008-02-08 04:20:36 -0800806 inode->i_ctime = dir->i_ctime = dir->i_mtime =
807 current_fs_time(dir->i_sb);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700808 mark_inode_dirty(dir);
809
Cyrill Gorcunov28de7942007-07-21 04:37:18 -0700810end_rmdir:
Linus Torvalds1da177e2005-04-16 15:20:36 -0700811 if (fibh.sbh != fibh.ebh)
Jan Kara3bf25cb2007-05-08 00:35:16 -0700812 brelse(fibh.ebh);
813 brelse(fibh.sbh);
Cyrill Gorcunov28de7942007-07-21 04:37:18 -0700814
815out:
Linus Torvalds1da177e2005-04-16 15:20:36 -0700816 unlock_kernel();
817 return retval;
818}
819
Cyrill Gorcunovcb00ea32007-07-19 01:47:43 -0700820static int udf_unlink(struct inode *dir, struct dentry *dentry)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700821{
822 int retval;
Cyrill Gorcunovcb00ea32007-07-19 01:47:43 -0700823 struct inode *inode = dentry->d_inode;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700824 struct udf_fileident_bh fibh;
825 struct fileIdentDesc *fi;
826 struct fileIdentDesc cfi;
827 kernel_lb_addr tloc;
828
829 retval = -ENOENT;
830 lock_kernel();
Al Viro9fbb76c2008-10-12 00:15:17 -0400831 fi = udf_find_entry(dir, &dentry->d_name, &fibh, &cfi);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700832 if (!fi)
833 goto out;
834
835 retval = -EIO;
836 tloc = lelb_to_cpu(cfi.icb.extLocation);
837 if (udf_get_lb_pblock(dir->i_sb, tloc, 0) != inode->i_ino)
838 goto end_unlink;
839
Cyrill Gorcunovcb00ea32007-07-19 01:47:43 -0700840 if (!inode->i_nlink) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700841 udf_debug("Deleting nonexistent file (%lu), %d\n",
Cyrill Gorcunovcb00ea32007-07-19 01:47:43 -0700842 inode->i_ino, inode->i_nlink);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700843 inode->i_nlink = 1;
844 }
845 retval = udf_delete_entry(dir, fi, &fibh, &cfi);
846 if (retval)
847 goto end_unlink;
848 dir->i_ctime = dir->i_mtime = current_fs_time(dir->i_sb);
849 mark_inode_dirty(dir);
Dave Hansen9a53c3a2006-09-30 23:29:03 -0700850 inode_dec_link_count(inode);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700851 inode->i_ctime = dir->i_ctime;
852 retval = 0;
853
Cyrill Gorcunov28de7942007-07-21 04:37:18 -0700854end_unlink:
Linus Torvalds1da177e2005-04-16 15:20:36 -0700855 if (fibh.sbh != fibh.ebh)
Jan Kara3bf25cb2007-05-08 00:35:16 -0700856 brelse(fibh.ebh);
857 brelse(fibh.sbh);
Cyrill Gorcunov28de7942007-07-21 04:37:18 -0700858
859out:
Linus Torvalds1da177e2005-04-16 15:20:36 -0700860 unlock_kernel();
861 return retval;
862}
863
Cyrill Gorcunovcb00ea32007-07-19 01:47:43 -0700864static int udf_symlink(struct inode *dir, struct dentry *dentry,
865 const char *symname)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700866{
Cyrill Gorcunovcb00ea32007-07-19 01:47:43 -0700867 struct inode *inode;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700868 struct pathComponent *pc;
869 char *compstart;
870 struct udf_fileident_bh fibh;
Cyrill Gorcunov28de7942007-07-21 04:37:18 -0700871 struct extent_position epos = {};
Linus Torvalds1da177e2005-04-16 15:20:36 -0700872 int eoffset, elen = 0;
873 struct fileIdentDesc *fi;
874 struct fileIdentDesc cfi;
875 char *ea;
876 int err;
877 int block;
Jan Karab80697c2008-03-04 14:14:05 +0100878 char *name = NULL;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700879 int namelen;
Marcin Slusarz6c79e982008-02-08 04:20:30 -0800880 struct buffer_head *bh;
Marcin Slusarz48d6d8f2008-02-08 04:20:44 -0800881 struct udf_inode_info *iinfo;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700882
883 lock_kernel();
Marcin Slusarz4b111112008-02-08 04:20:36 -0800884 inode = udf_new_inode(dir, S_IFLNK, &err);
885 if (!inode)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700886 goto out;
887
Jan Karab80697c2008-03-04 14:14:05 +0100888 name = kmalloc(UDF_NAME_LEN, GFP_NOFS);
889 if (!name) {
890 err = -ENOMEM;
891 goto out_no_entry;
892 }
893
Marcin Slusarz48d6d8f2008-02-08 04:20:44 -0800894 iinfo = UDF_I(inode);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700895 inode->i_mode = S_IFLNK | S_IRWXUGO;
896 inode->i_data.a_ops = &udf_symlink_aops;
897 inode->i_op = &page_symlink_inode_operations;
898
Marcin Slusarz48d6d8f2008-02-08 04:20:44 -0800899 if (iinfo->i_alloc_type != ICBTAG_FLAG_AD_IN_ICB) {
Jan Karaff116fc2007-05-08 00:35:14 -0700900 kernel_lb_addr eloc;
Harvey Harrison78e917d2008-04-28 02:16:19 -0700901 uint32_t bsize;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700902
903 block = udf_new_block(inode->i_sb, inode,
Marcin Slusarz48d6d8f2008-02-08 04:20:44 -0800904 iinfo->i_location.partitionReferenceNum,
905 iinfo->i_location.logicalBlockNum, &err);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700906 if (!block)
907 goto out_no_entry;
Marcin Slusarz48d6d8f2008-02-08 04:20:44 -0800908 epos.block = iinfo->i_location;
Jan Karaff116fc2007-05-08 00:35:14 -0700909 epos.offset = udf_file_entry_alloc_offset(inode);
910 epos.bh = NULL;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700911 eloc.logicalBlockNum = block;
Marcin Slusarz4b111112008-02-08 04:20:36 -0800912 eloc.partitionReferenceNum =
Marcin Slusarz48d6d8f2008-02-08 04:20:44 -0800913 iinfo->i_location.partitionReferenceNum;
Harvey Harrison78e917d2008-04-28 02:16:19 -0700914 bsize = inode->i_sb->s_blocksize;
915 iinfo->i_lenExtents = bsize;
916 udf_add_aext(inode, &epos, eloc, bsize, 0);
Jan Kara3bf25cb2007-05-08 00:35:16 -0700917 brelse(epos.bh);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700918
919 block = udf_get_pblock(inode->i_sb, block,
Marcin Slusarz48d6d8f2008-02-08 04:20:44 -0800920 iinfo->i_location.partitionReferenceNum,
Marcin Slusarz4b111112008-02-08 04:20:36 -0800921 0);
Jan Karaff116fc2007-05-08 00:35:14 -0700922 epos.bh = udf_tread(inode->i_sb, block);
923 lock_buffer(epos.bh);
924 memset(epos.bh->b_data, 0x00, inode->i_sb->s_blocksize);
925 set_buffer_uptodate(epos.bh);
926 unlock_buffer(epos.bh);
927 mark_buffer_dirty_inode(epos.bh, inode);
928 ea = epos.bh->b_data + udf_ext0_offset(inode);
Marcin Slusarz48d6d8f2008-02-08 04:20:44 -0800929 } else
930 ea = iinfo->i_ext.i_data + iinfo->i_lenEAttr;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700931
932 eoffset = inode->i_sb->s_blocksize - udf_ext0_offset(inode);
933 pc = (struct pathComponent *)ea;
934
Cyrill Gorcunovcb00ea32007-07-19 01:47:43 -0700935 if (*symname == '/') {
936 do {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700937 symname++;
938 } while (*symname == '/');
939
940 pc->componentType = 1;
941 pc->lengthComponentIdent = 0;
942 pc->componentFileVersionNum = 0;
943 pc += sizeof(struct pathComponent);
944 elen += sizeof(struct pathComponent);
945 }
946
947 err = -ENAMETOOLONG;
948
Cyrill Gorcunovcb00ea32007-07-19 01:47:43 -0700949 while (*symname) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700950 if (elen + sizeof(struct pathComponent) > eoffset)
951 goto out_no_entry;
952
953 pc = (struct pathComponent *)(ea + elen);
954
955 compstart = (char *)symname;
956
Cyrill Gorcunovcb00ea32007-07-19 01:47:43 -0700957 do {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700958 symname++;
959 } while (*symname && *symname != '/');
960
961 pc->componentType = 5;
962 pc->lengthComponentIdent = 0;
963 pc->componentFileVersionNum = 0;
Cyrill Gorcunovcb00ea32007-07-19 01:47:43 -0700964 if (compstart[0] == '.') {
965 if ((symname - compstart) == 1)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700966 pc->componentType = 4;
Marcin Slusarz4b111112008-02-08 04:20:36 -0800967 else if ((symname - compstart) == 2 &&
968 compstart[1] == '.')
Linus Torvalds1da177e2005-04-16 15:20:36 -0700969 pc->componentType = 3;
970 }
971
Cyrill Gorcunovcb00ea32007-07-19 01:47:43 -0700972 if (pc->componentType == 5) {
Cyrill Gorcunov28de7942007-07-21 04:37:18 -0700973 namelen = udf_put_filename(inode->i_sb, compstart, name,
974 symname - compstart);
975 if (!namelen)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700976 goto out_no_entry;
977
Marcin Slusarz4b111112008-02-08 04:20:36 -0800978 if (elen + sizeof(struct pathComponent) + namelen >
979 eoffset)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700980 goto out_no_entry;
981 else
982 pc->lengthComponentIdent = namelen;
983
984 memcpy(pc->componentIdent, name, namelen);
985 }
986
987 elen += sizeof(struct pathComponent) + pc->lengthComponentIdent;
988
Cyrill Gorcunovcb00ea32007-07-19 01:47:43 -0700989 if (*symname) {
990 do {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700991 symname++;
992 } while (*symname == '/');
993 }
994 }
995
Jan Kara3bf25cb2007-05-08 00:35:16 -0700996 brelse(epos.bh);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700997 inode->i_size = elen;
Marcin Slusarz48d6d8f2008-02-08 04:20:44 -0800998 if (iinfo->i_alloc_type == ICBTAG_FLAG_AD_IN_ICB)
999 iinfo->i_lenAlloc = inode->i_size;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001000 mark_inode_dirty(inode);
1001
Marcin Slusarz4b111112008-02-08 04:20:36 -08001002 fi = udf_add_entry(dir, dentry, &fibh, &cfi, &err);
1003 if (!fi)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001004 goto out_no_entry;
1005 cfi.icb.extLength = cpu_to_le32(inode->i_sb->s_blocksize);
Marcin Slusarz48d6d8f2008-02-08 04:20:44 -08001006 cfi.icb.extLocation = cpu_to_lelb(iinfo->i_location);
Marcin Slusarz6c79e982008-02-08 04:20:30 -08001007 bh = UDF_SB(inode->i_sb)->s_lvid_bh;
1008 if (bh) {
Marcin Slusarz4b111112008-02-08 04:20:36 -08001009 struct logicalVolIntegrityDesc *lvid =
1010 (struct logicalVolIntegrityDesc *)bh->b_data;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001011 struct logicalVolHeaderDesc *lvhd;
1012 uint64_t uniqueID;
Marcin Slusarz4b111112008-02-08 04:20:36 -08001013 lvhd = (struct logicalVolHeaderDesc *)
1014 lvid->logicalVolContentsUse;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001015 uniqueID = le64_to_cpu(lvhd->uniqueID);
Cyrill Gorcunov28de7942007-07-21 04:37:18 -07001016 *(__le32 *)((struct allocDescImpUse *)cfi.icb.impUse)->impUse =
1017 cpu_to_le32(uniqueID & 0x00000000FFFFFFFFUL);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001018 if (!(++uniqueID & 0x00000000FFFFFFFFUL))
1019 uniqueID += 16;
1020 lvhd->uniqueID = cpu_to_le64(uniqueID);
Marcin Slusarz6c79e982008-02-08 04:20:30 -08001021 mark_buffer_dirty(bh);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001022 }
1023 udf_write_fi(dir, &cfi, fi, &fibh, NULL, NULL);
Marcin Slusarzc0b34432008-02-08 04:20:42 -08001024 if (UDF_I(dir)->i_alloc_type == ICBTAG_FLAG_AD_IN_ICB)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001025 mark_inode_dirty(dir);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001026 if (fibh.sbh != fibh.ebh)
Jan Kara3bf25cb2007-05-08 00:35:16 -07001027 brelse(fibh.ebh);
1028 brelse(fibh.sbh);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001029 d_instantiate(dentry, inode);
1030 err = 0;
1031
Cyrill Gorcunov28de7942007-07-21 04:37:18 -07001032out:
Jan Karab80697c2008-03-04 14:14:05 +01001033 kfree(name);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001034 unlock_kernel();
1035 return err;
1036
Cyrill Gorcunov28de7942007-07-21 04:37:18 -07001037out_no_entry:
Dave Hansen9a53c3a2006-09-30 23:29:03 -07001038 inode_dec_link_count(inode);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001039 iput(inode);
1040 goto out;
1041}
1042
Cyrill Gorcunovcb00ea32007-07-19 01:47:43 -07001043static int udf_link(struct dentry *old_dentry, struct inode *dir,
1044 struct dentry *dentry)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001045{
1046 struct inode *inode = old_dentry->d_inode;
1047 struct udf_fileident_bh fibh;
1048 struct fileIdentDesc cfi, *fi;
1049 int err;
Marcin Slusarz6c79e982008-02-08 04:20:30 -08001050 struct buffer_head *bh;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001051
1052 lock_kernel();
Cyrill Gorcunovcb00ea32007-07-19 01:47:43 -07001053 if (inode->i_nlink >= (256 << sizeof(inode->i_nlink)) - 1) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001054 unlock_kernel();
1055 return -EMLINK;
1056 }
1057
Marcin Slusarz4b111112008-02-08 04:20:36 -08001058 fi = udf_add_entry(dir, dentry, &fibh, &cfi, &err);
1059 if (!fi) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001060 unlock_kernel();
1061 return err;
1062 }
1063 cfi.icb.extLength = cpu_to_le32(inode->i_sb->s_blocksize);
Marcin Slusarzc0b34432008-02-08 04:20:42 -08001064 cfi.icb.extLocation = cpu_to_lelb(UDF_I(inode)->i_location);
Marcin Slusarz6c79e982008-02-08 04:20:30 -08001065 bh = UDF_SB(inode->i_sb)->s_lvid_bh;
1066 if (bh) {
Marcin Slusarz4b111112008-02-08 04:20:36 -08001067 struct logicalVolIntegrityDesc *lvid =
1068 (struct logicalVolIntegrityDesc *)bh->b_data;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001069 struct logicalVolHeaderDesc *lvhd;
1070 uint64_t uniqueID;
Marcin Slusarz4b111112008-02-08 04:20:36 -08001071 lvhd = (struct logicalVolHeaderDesc *)
1072 (lvid->logicalVolContentsUse);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001073 uniqueID = le64_to_cpu(lvhd->uniqueID);
Cyrill Gorcunov28de7942007-07-21 04:37:18 -07001074 *(__le32 *)((struct allocDescImpUse *)cfi.icb.impUse)->impUse =
1075 cpu_to_le32(uniqueID & 0x00000000FFFFFFFFUL);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001076 if (!(++uniqueID & 0x00000000FFFFFFFFUL))
1077 uniqueID += 16;
1078 lvhd->uniqueID = cpu_to_le64(uniqueID);
Marcin Slusarz6c79e982008-02-08 04:20:30 -08001079 mark_buffer_dirty(bh);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001080 }
1081 udf_write_fi(dir, &cfi, fi, &fibh, NULL, NULL);
Marcin Slusarzc0b34432008-02-08 04:20:42 -08001082 if (UDF_I(dir)->i_alloc_type == ICBTAG_FLAG_AD_IN_ICB)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001083 mark_inode_dirty(dir);
Cyrill Gorcunov28de7942007-07-21 04:37:18 -07001084
Linus Torvalds1da177e2005-04-16 15:20:36 -07001085 if (fibh.sbh != fibh.ebh)
Jan Kara3bf25cb2007-05-08 00:35:16 -07001086 brelse(fibh.ebh);
1087 brelse(fibh.sbh);
Dave Hansend8c76e62006-09-30 23:29:04 -07001088 inc_nlink(inode);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001089 inode->i_ctime = current_fs_time(inode->i_sb);
1090 mark_inode_dirty(inode);
1091 atomic_inc(&inode->i_count);
1092 d_instantiate(dentry, inode);
1093 unlock_kernel();
Cyrill Gorcunov28de7942007-07-21 04:37:18 -07001094
Linus Torvalds1da177e2005-04-16 15:20:36 -07001095 return 0;
1096}
1097
1098/* Anybody can rename anything with this: the permission checks are left to the
1099 * higher-level routines.
1100 */
Cyrill Gorcunovcb00ea32007-07-19 01:47:43 -07001101static int udf_rename(struct inode *old_dir, struct dentry *old_dentry,
1102 struct inode *new_dir, struct dentry *new_dentry)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001103{
Cyrill Gorcunovcb00ea32007-07-19 01:47:43 -07001104 struct inode *old_inode = old_dentry->d_inode;
1105 struct inode *new_inode = new_dentry->d_inode;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001106 struct udf_fileident_bh ofibh, nfibh;
Marcin Slusarz4b111112008-02-08 04:20:36 -08001107 struct fileIdentDesc *ofi = NULL, *nfi = NULL, *dir_fi = NULL;
1108 struct fileIdentDesc ocfi, ncfi;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001109 struct buffer_head *dir_bh = NULL;
1110 int retval = -ENOENT;
1111 kernel_lb_addr tloc;
Marcin Slusarz48d6d8f2008-02-08 04:20:44 -08001112 struct udf_inode_info *old_iinfo = UDF_I(old_inode);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001113
1114 lock_kernel();
Al Viro9fbb76c2008-10-12 00:15:17 -04001115 ofi = udf_find_entry(old_dir, &old_dentry->d_name, &ofibh, &ocfi);
Marcin Slusarz4b111112008-02-08 04:20:36 -08001116 if (ofi) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001117 if (ofibh.sbh != ofibh.ebh)
Jan Kara3bf25cb2007-05-08 00:35:16 -07001118 brelse(ofibh.ebh);
1119 brelse(ofibh.sbh);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001120 }
1121 tloc = lelb_to_cpu(ocfi.icb.extLocation);
1122 if (!ofi || udf_get_lb_pblock(old_dir->i_sb, tloc, 0)
Cyrill Gorcunovcb00ea32007-07-19 01:47:43 -07001123 != old_inode->i_ino)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001124 goto end_rename;
1125
Al Viro9fbb76c2008-10-12 00:15:17 -04001126 nfi = udf_find_entry(new_dir, &new_dentry->d_name, &nfibh, &ncfi);
Cyrill Gorcunovcb00ea32007-07-19 01:47:43 -07001127 if (nfi) {
1128 if (!new_inode) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001129 if (nfibh.sbh != nfibh.ebh)
Jan Kara3bf25cb2007-05-08 00:35:16 -07001130 brelse(nfibh.ebh);
1131 brelse(nfibh.sbh);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001132 nfi = NULL;
1133 }
1134 }
Cyrill Gorcunovcb00ea32007-07-19 01:47:43 -07001135 if (S_ISDIR(old_inode->i_mode)) {
Marcin Slusarz7f3fbd02008-02-08 04:20:49 -08001136 int offset = udf_ext0_offset(old_inode);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001137
Cyrill Gorcunovcb00ea32007-07-19 01:47:43 -07001138 if (new_inode) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001139 retval = -ENOTEMPTY;
1140 if (!empty_dir(new_inode))
1141 goto end_rename;
1142 }
1143 retval = -EIO;
Marcin Slusarz48d6d8f2008-02-08 04:20:44 -08001144 if (old_iinfo->i_alloc_type == ICBTAG_FLAG_AD_IN_ICB) {
Marcin Slusarz4b111112008-02-08 04:20:36 -08001145 dir_fi = udf_get_fileident(
Marcin Slusarz48d6d8f2008-02-08 04:20:44 -08001146 old_iinfo->i_ext.i_data -
1147 (old_iinfo->i_efe ?
Marcin Slusarz4b111112008-02-08 04:20:36 -08001148 sizeof(struct extendedFileEntry) :
1149 sizeof(struct fileEntry)),
1150 old_inode->i_sb->s_blocksize, &offset);
Cyrill Gorcunovcb00ea32007-07-19 01:47:43 -07001151 } else {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001152 dir_bh = udf_bread(old_inode, 0, 0, &retval);
1153 if (!dir_bh)
1154 goto end_rename;
Marcin Slusarz4b111112008-02-08 04:20:36 -08001155 dir_fi = udf_get_fileident(dir_bh->b_data,
1156 old_inode->i_sb->s_blocksize, &offset);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001157 }
1158 if (!dir_fi)
1159 goto end_rename;
1160 tloc = lelb_to_cpu(dir_fi->icb.extLocation);
Marcin Slusarz4b111112008-02-08 04:20:36 -08001161 if (udf_get_lb_pblock(old_inode->i_sb, tloc, 0) !=
1162 old_dir->i_ino)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001163 goto end_rename;
1164
1165 retval = -EMLINK;
Marcin Slusarz4b111112008-02-08 04:20:36 -08001166 if (!new_inode &&
1167 new_dir->i_nlink >=
1168 (256 << sizeof(new_dir->i_nlink)) - 1)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001169 goto end_rename;
1170 }
Cyrill Gorcunovcb00ea32007-07-19 01:47:43 -07001171 if (!nfi) {
Marcin Slusarz4b111112008-02-08 04:20:36 -08001172 nfi = udf_add_entry(new_dir, new_dentry, &nfibh, &ncfi,
1173 &retval);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001174 if (!nfi)
1175 goto end_rename;
1176 }
1177
1178 /*
1179 * Like most other Unix systems, set the ctime for inodes on a
1180 * rename.
1181 */
1182 old_inode->i_ctime = current_fs_time(old_inode->i_sb);
1183 mark_inode_dirty(old_inode);
1184
1185 /*
1186 * ok, that's it
1187 */
1188 ncfi.fileVersionNum = ocfi.fileVersionNum;
1189 ncfi.fileCharacteristics = ocfi.fileCharacteristics;
1190 memcpy(&(ncfi.icb), &(ocfi.icb), sizeof(long_ad));
1191 udf_write_fi(new_dir, &ncfi, nfi, &nfibh, NULL, NULL);
1192
1193 /* The old fid may have moved - find it again */
Al Viro9fbb76c2008-10-12 00:15:17 -04001194 ofi = udf_find_entry(old_dir, &old_dentry->d_name, &ofibh, &ocfi);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001195 udf_delete_entry(old_dir, ofi, &ofibh, &ocfi);
1196
Cyrill Gorcunovcb00ea32007-07-19 01:47:43 -07001197 if (new_inode) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001198 new_inode->i_ctime = current_fs_time(new_inode->i_sb);
Dave Hansen9a53c3a2006-09-30 23:29:03 -07001199 inode_dec_link_count(new_inode);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001200 }
1201 old_dir->i_ctime = old_dir->i_mtime = current_fs_time(old_dir->i_sb);
1202 mark_inode_dirty(old_dir);
1203
Cyrill Gorcunovcb00ea32007-07-19 01:47:43 -07001204 if (dir_fi) {
Marcin Slusarzc0b34432008-02-08 04:20:42 -08001205 dir_fi->icb.extLocation = cpu_to_lelb(UDF_I(new_dir)->i_location);
Marcin Slusarz4b111112008-02-08 04:20:36 -08001206 udf_update_tag((char *)dir_fi,
1207 (sizeof(struct fileIdentDesc) +
1208 le16_to_cpu(dir_fi->lengthOfImpUse) + 3) & ~3);
Marcin Slusarz48d6d8f2008-02-08 04:20:44 -08001209 if (old_iinfo->i_alloc_type == ICBTAG_FLAG_AD_IN_ICB)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001210 mark_inode_dirty(old_inode);
Marcin Slusarz4b111112008-02-08 04:20:36 -08001211 else
Linus Torvalds1da177e2005-04-16 15:20:36 -07001212 mark_buffer_dirty_inode(dir_bh, old_inode);
Marcin Slusarz4b111112008-02-08 04:20:36 -08001213
Dave Hansen9a53c3a2006-09-30 23:29:03 -07001214 inode_dec_link_count(old_dir);
Marcin Slusarz4b111112008-02-08 04:20:36 -08001215 if (new_inode)
Dave Hansen9a53c3a2006-09-30 23:29:03 -07001216 inode_dec_link_count(new_inode);
Marcin Slusarz4b111112008-02-08 04:20:36 -08001217 else {
Dave Hansend8c76e62006-09-30 23:29:04 -07001218 inc_nlink(new_dir);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001219 mark_inode_dirty(new_dir);
1220 }
1221 }
1222
Cyrill Gorcunovcb00ea32007-07-19 01:47:43 -07001223 if (ofi) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001224 if (ofibh.sbh != ofibh.ebh)
Jan Kara3bf25cb2007-05-08 00:35:16 -07001225 brelse(ofibh.ebh);
1226 brelse(ofibh.sbh);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001227 }
1228
1229 retval = 0;
1230
Cyrill Gorcunov28de7942007-07-21 04:37:18 -07001231end_rename:
Jan Kara3bf25cb2007-05-08 00:35:16 -07001232 brelse(dir_bh);
Cyrill Gorcunovcb00ea32007-07-19 01:47:43 -07001233 if (nfi) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001234 if (nfibh.sbh != nfibh.ebh)
Jan Kara3bf25cb2007-05-08 00:35:16 -07001235 brelse(nfibh.ebh);
1236 brelse(nfibh.sbh);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001237 }
1238 unlock_kernel();
Cyrill Gorcunov28de7942007-07-21 04:37:18 -07001239
Linus Torvalds1da177e2005-04-16 15:20:36 -07001240 return retval;
1241}
1242
Rasmus Rohde221e5832008-04-30 17:22:06 +02001243static struct dentry *udf_get_parent(struct dentry *child)
1244{
Rasmus Rohde221e5832008-04-30 17:22:06 +02001245 struct inode *inode = NULL;
Al Viro9fbb76c2008-10-12 00:15:17 -04001246 struct qstr dotdot = {.name = "..", .len = 2};
Rasmus Rohde221e5832008-04-30 17:22:06 +02001247 struct fileIdentDesc cfi;
1248 struct udf_fileident_bh fibh;
1249
Rasmus Rohde221e5832008-04-30 17:22:06 +02001250 lock_kernel();
1251 if (!udf_find_entry(child->d_inode, &dotdot, &fibh, &cfi))
1252 goto out_unlock;
1253
1254 if (fibh.sbh != fibh.ebh)
1255 brelse(fibh.ebh);
1256 brelse(fibh.sbh);
1257
1258 inode = udf_iget(child->d_inode->i_sb,
1259 lelb_to_cpu(cfi.icb.extLocation));
1260 if (!inode)
1261 goto out_unlock;
1262 unlock_kernel();
1263
Christoph Hellwig44003722008-08-11 15:49:04 +02001264 return d_obtain_alias(inode);
Rasmus Rohde221e5832008-04-30 17:22:06 +02001265out_unlock:
1266 unlock_kernel();
1267 return ERR_PTR(-EACCES);
1268}
1269
1270
1271static struct dentry *udf_nfs_get_inode(struct super_block *sb, u32 block,
1272 u16 partref, __u32 generation)
1273{
1274 struct inode *inode;
Rasmus Rohde221e5832008-04-30 17:22:06 +02001275 kernel_lb_addr loc;
1276
1277 if (block == 0)
1278 return ERR_PTR(-ESTALE);
1279
1280 loc.logicalBlockNum = block;
1281 loc.partitionReferenceNum = partref;
1282 inode = udf_iget(sb, loc);
1283
1284 if (inode == NULL)
1285 return ERR_PTR(-ENOMEM);
1286
1287 if (generation && inode->i_generation != generation) {
1288 iput(inode);
1289 return ERR_PTR(-ESTALE);
1290 }
Christoph Hellwig44003722008-08-11 15:49:04 +02001291 return d_obtain_alias(inode);
Rasmus Rohde221e5832008-04-30 17:22:06 +02001292}
1293
1294static struct dentry *udf_fh_to_dentry(struct super_block *sb,
1295 struct fid *fid, int fh_len, int fh_type)
1296{
1297 if ((fh_len != 3 && fh_len != 5) ||
1298 (fh_type != FILEID_UDF_WITH_PARENT &&
1299 fh_type != FILEID_UDF_WITHOUT_PARENT))
1300 return NULL;
1301
1302 return udf_nfs_get_inode(sb, fid->udf.block, fid->udf.partref,
1303 fid->udf.generation);
1304}
1305
1306static struct dentry *udf_fh_to_parent(struct super_block *sb,
1307 struct fid *fid, int fh_len, int fh_type)
1308{
1309 if (fh_len != 5 || fh_type != FILEID_UDF_WITH_PARENT)
1310 return NULL;
1311
1312 return udf_nfs_get_inode(sb, fid->udf.parent_block,
1313 fid->udf.parent_partref,
1314 fid->udf.parent_generation);
1315}
1316static int udf_encode_fh(struct dentry *de, __u32 *fh, int *lenp,
1317 int connectable)
1318{
1319 int len = *lenp;
1320 struct inode *inode = de->d_inode;
1321 kernel_lb_addr location = UDF_I(inode)->i_location;
1322 struct fid *fid = (struct fid *)fh;
1323 int type = FILEID_UDF_WITHOUT_PARENT;
1324
1325 if (len < 3 || (connectable && len < 5))
1326 return 255;
1327
1328 *lenp = 3;
1329 fid->udf.block = location.logicalBlockNum;
1330 fid->udf.partref = location.partitionReferenceNum;
1331 fid->udf.generation = inode->i_generation;
1332
1333 if (connectable && !S_ISDIR(inode->i_mode)) {
1334 spin_lock(&de->d_lock);
1335 inode = de->d_parent->d_inode;
1336 location = UDF_I(inode)->i_location;
1337 fid->udf.parent_block = location.logicalBlockNum;
1338 fid->udf.parent_partref = location.partitionReferenceNum;
1339 fid->udf.parent_generation = inode->i_generation;
1340 spin_unlock(&de->d_lock);
1341 *lenp = 5;
1342 type = FILEID_UDF_WITH_PARENT;
1343 }
1344
1345 return type;
1346}
1347
1348const struct export_operations udf_export_ops = {
1349 .encode_fh = udf_encode_fh,
1350 .fh_to_dentry = udf_fh_to_dentry,
1351 .fh_to_parent = udf_fh_to_parent,
1352 .get_parent = udf_get_parent,
1353};
1354
Arjan van de Venc5ef1c42007-02-12 00:55:40 -08001355const struct inode_operations udf_dir_inode_operations = {
Cyrill Gorcunov28de7942007-07-21 04:37:18 -07001356 .lookup = udf_lookup,
1357 .create = udf_create,
1358 .link = udf_link,
1359 .unlink = udf_unlink,
1360 .symlink = udf_symlink,
1361 .mkdir = udf_mkdir,
1362 .rmdir = udf_rmdir,
1363 .mknod = udf_mknod,
1364 .rename = udf_rename,
Linus Torvalds1da177e2005-04-16 15:20:36 -07001365};