blob: f1c64c6a45329c3d2262ed678a63eba396886fa3 [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>
Linus Torvalds1da177e2005-04-16 15:20:36 -070030#include <linux/buffer_head.h>
Alexey Dobriyane8edc6e2007-05-21 01:22:52 +040031#include <linux/sched.h>
Bob Copelandf845fce2008-04-17 09:47:48 +020032#include <linux/crc-itu-t.h>
Rasmus Rohde221e5832008-04-30 17:22:06 +020033#include <linux/exportfs.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070034
Al Viro810c1b2e2011-03-02 10:15:26 -050035enum { UDF_MAX_LINKS = 0xffff };
36
Al Viro391e8bb2010-01-31 21:28:48 -050037static inline int udf_match(int len1, const unsigned char *name1, int len2,
38 const unsigned 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{
Pekka Enberg5ca4e4b2008-10-15 12:28:03 +020050 uint16_t crclen = fibh->eoffset - fibh->soffset - sizeof(struct tag);
Linus Torvalds1da177e2005-04-16 15:20:36 -070051 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
Pekka Enberg5ca4e4b2008-10-15 12:28:03 +0200102 crc = crc_itu_t(0, (uint8_t *)cfi + sizeof(struct tag),
103 sizeof(struct fileIdentDesc) - sizeof(struct 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,
Pekka Enberg5ca4e4b2008-10-15 12:28:03 +0200107 crclen + sizeof(struct 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,
Pekka Enberg5ca4e4b2008-10-15 12:28:03 +0200113 crclen + sizeof(struct 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 Viro391e8bb2010-01-31 21:28:48 -0500145 const 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;
Al Viro391e8bb2010-01-31 21:28:48 -0500152 unsigned char *fname = NULL;
153 unsigned char *nameptr;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700154 uint8_t lfi;
155 uint16_t liu;
KAMBAROV, ZAURec471dc2005-06-28 20:45:10 -0700156 loff_t size;
Pekka Enberg5ca4e4b2008-10-15 12:28:03 +0200157 struct kernel_lb_addr eloc;
Jan Karaff116fc2007-05-08 00:35:14 -0700158 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;
Pekka Enberg97e961f2008-10-15 12:29:03 +0200174 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)
Pekka Enberg5ca4e4b2008-10-15 12:28:03 +0200177 epos.offset -= sizeof(struct short_ad);
Marcin Slusarz48d6d8f2008-02-08 04:20:44 -0800178 else if (dinfo->i_alloc_type == ICBTAG_FLAG_AD_LONG)
Pekka Enberg5ca4e4b2008-10-15 12:28:03 +0200179 epos.offset -= sizeof(struct 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) &&
Jesper Juhla4264b32010-12-12 23:18:15 +0100232 isdotdot)
233 goto out_ok;
Rasmus Rohde221e5832008-04-30 17:22:06 +0200234
Linus Torvalds1da177e2005-04-16 15:20:36 -0700235 if (!lfi)
236 continue;
237
Marcin Slusarz4b111112008-02-08 04:20:36 -0800238 flen = udf_get_filename(dir->i_sb, nameptr, fname, lfi);
Al Viro9fbb76c2008-10-12 00:15:17 -0400239 if (flen && udf_match(flen, fname, child->len, child->name))
Jan Karab80697c2008-03-04 14:14:05 +0100240 goto out_ok;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700241 }
Cyrill Gorcunov28de7942007-07-21 04:37:18 -0700242
Jan Karab80697c2008-03-04 14:14:05 +0100243out_err:
244 fi = NULL;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700245 if (fibh->sbh != fibh->ebh)
Jan Kara3bf25cb2007-05-08 00:35:16 -0700246 brelse(fibh->ebh);
247 brelse(fibh->sbh);
Jan Karab80697c2008-03-04 14:14:05 +0100248out_ok:
Jan Kara3bf25cb2007-05-08 00:35:16 -0700249 brelse(epos.bh);
Jan Karab80697c2008-03-04 14:14:05 +0100250 kfree(fname);
Cyrill Gorcunov28de7942007-07-21 04:37:18 -0700251
Jan Karab80697c2008-03-04 14:14:05 +0100252 return fi;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700253}
254
Cyrill Gorcunovcb00ea32007-07-19 01:47:43 -0700255static struct dentry *udf_lookup(struct inode *dir, struct dentry *dentry,
256 struct nameidata *nd)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700257{
258 struct inode *inode = NULL;
Jayachandran Cdb9a3692006-02-03 03:04:50 -0800259 struct fileIdentDesc cfi;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700260 struct udf_fileident_bh fibh;
261
Cyrill Gorcunovcb00ea32007-07-19 01:47:43 -0700262 if (dentry->d_name.len > UDF_NAME_LEN - 2)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700263 return ERR_PTR(-ENAMETOOLONG);
264
Linus Torvalds1da177e2005-04-16 15:20:36 -0700265#ifdef UDF_RECOVERY
266 /* temporary shorthand for specifying files by inode number */
Cyrill Gorcunovcb00ea32007-07-19 01:47:43 -0700267 if (!strncmp(dentry->d_name.name, ".B=", 3)) {
Pekka Enberg5ca4e4b2008-10-15 12:28:03 +0200268 struct kernel_lb_addr lb = {
Cyrill Gorcunov28de7942007-07-21 04:37:18 -0700269 .logicalBlockNum = 0,
Marcin Slusarz4b111112008-02-08 04:20:36 -0800270 .partitionReferenceNum =
271 simple_strtoul(dentry->d_name.name + 3,
272 NULL, 0),
Cyrill Gorcunov28de7942007-07-21 04:37:18 -0700273 };
Linus Torvalds1da177e2005-04-16 15:20:36 -0700274 inode = udf_iget(dir->i_sb, lb);
Cyrill Gorcunovcb00ea32007-07-19 01:47:43 -0700275 if (!inode) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700276 return ERR_PTR(-EACCES);
277 }
Marcin Slusarz4b111112008-02-08 04:20:36 -0800278 } else
Cyrill Gorcunov28de7942007-07-21 04:37:18 -0700279#endif /* UDF_RECOVERY */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700280
Al Viro9fbb76c2008-10-12 00:15:17 -0400281 if (udf_find_entry(dir, &dentry->d_name, &fibh, &cfi)) {
Pekka Enberg97e961f2008-10-15 12:29:03 +0200282 struct kernel_lb_addr loc;
283
Linus Torvalds1da177e2005-04-16 15:20:36 -0700284 if (fibh.sbh != fibh.ebh)
Jan Kara3bf25cb2007-05-08 00:35:16 -0700285 brelse(fibh.ebh);
286 brelse(fibh.sbh);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700287
Pekka Enberg97e961f2008-10-15 12:29:03 +0200288 loc = lelb_to_cpu(cfi.icb.extLocation);
289 inode = udf_iget(dir->i_sb, &loc);
Cyrill Gorcunovcb00ea32007-07-19 01:47:43 -0700290 if (!inode) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700291 return ERR_PTR(-EACCES);
292 }
293 }
Cyrill Gorcunov28de7942007-07-21 04:37:18 -0700294
Rasmus Rohde221e5832008-04-30 17:22:06 +0200295 return d_splice_alias(inode, dentry);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700296}
297
Cyrill Gorcunovcb00ea32007-07-19 01:47:43 -0700298static struct fileIdentDesc *udf_add_entry(struct inode *dir,
299 struct dentry *dentry,
300 struct udf_fileident_bh *fibh,
301 struct fileIdentDesc *cfi, int *err)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700302{
Marcin Slusarz6c79e982008-02-08 04:20:30 -0800303 struct super_block *sb = dir->i_sb;
Cyrill Gorcunovcb00ea32007-07-19 01:47:43 -0700304 struct fileIdentDesc *fi = NULL;
Al Viro391e8bb2010-01-31 21:28:48 -0500305 unsigned char *name = NULL;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700306 int namelen;
307 loff_t f_pos;
Jan Karaaf793292008-02-08 04:20:50 -0800308 loff_t size = udf_ext0_offset(dir) + dir->i_size;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700309 int nfidlen;
310 uint8_t lfi;
311 uint16_t liu;
312 int block;
Pekka Enberg5ca4e4b2008-10-15 12:28:03 +0200313 struct kernel_lb_addr eloc;
Jan Kara9afadc42008-05-06 18:26:17 +0200314 uint32_t elen = 0;
Jan Kara60448b12007-05-08 00:35:13 -0700315 sector_t offset;
Cyrill Gorcunov28de7942007-07-21 04:37:18 -0700316 struct extent_position epos = {};
Marcin Slusarz48d6d8f2008-02-08 04:20:44 -0800317 struct udf_inode_info *dinfo;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700318
Jan Karab80697c2008-03-04 14:14:05 +0100319 fibh->sbh = fibh->ebh = NULL;
320 name = kmalloc(UDF_NAME_LEN, GFP_NOFS);
321 if (!name) {
322 *err = -ENOMEM;
323 goto out_err;
324 }
325
Cyrill Gorcunovcb00ea32007-07-19 01:47:43 -0700326 if (dentry) {
327 if (!dentry->d_name.len) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700328 *err = -EINVAL;
Jan Karab80697c2008-03-04 14:14:05 +0100329 goto out_err;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700330 }
Marcin Slusarz4b111112008-02-08 04:20:36 -0800331 namelen = udf_put_filename(sb, dentry->d_name.name, name,
332 dentry->d_name.len);
333 if (!namelen) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700334 *err = -ENAMETOOLONG;
Jan Karab80697c2008-03-04 14:14:05 +0100335 goto out_err;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700336 }
Cyrill Gorcunov28de7942007-07-21 04:37:18 -0700337 } else {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700338 namelen = 0;
Cyrill Gorcunov28de7942007-07-21 04:37:18 -0700339 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700340
341 nfidlen = (sizeof(struct fileIdentDesc) + namelen + 3) & ~3;
342
Jan Karaaf793292008-02-08 04:20:50 -0800343 f_pos = udf_ext0_offset(dir);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700344
Jan Karaaf793292008-02-08 04:20:50 -0800345 fibh->soffset = fibh->eoffset = f_pos & (dir->i_sb->s_blocksize - 1);
Marcin Slusarz48d6d8f2008-02-08 04:20:44 -0800346 dinfo = UDF_I(dir);
Jan Karab80697c2008-03-04 14:14:05 +0100347 if (dinfo->i_alloc_type != ICBTAG_FLAG_AD_IN_ICB) {
348 if (inode_bmap(dir, f_pos >> dir->i_sb->s_blocksize_bits, &epos,
349 &eloc, &elen, &offset) != (EXT_RECORDED_ALLOCATED >> 30)) {
350 block = udf_get_lb_pblock(dir->i_sb,
Pekka Enberg97e961f2008-10-15 12:29:03 +0200351 &dinfo->i_location, 0);
Jan Karab80697c2008-03-04 14:14:05 +0100352 fibh->soffset = fibh->eoffset = sb->s_blocksize;
353 goto add;
354 }
Pekka Enberg97e961f2008-10-15 12:29:03 +0200355 block = udf_get_lb_pblock(dir->i_sb, &eloc, offset);
Cyrill Gorcunovcb00ea32007-07-19 01:47:43 -0700356 if ((++offset << dir->i_sb->s_blocksize_bits) < elen) {
Marcin Slusarz48d6d8f2008-02-08 04:20:44 -0800357 if (dinfo->i_alloc_type == ICBTAG_FLAG_AD_SHORT)
Pekka Enberg5ca4e4b2008-10-15 12:28:03 +0200358 epos.offset -= sizeof(struct short_ad);
Marcin Slusarz48d6d8f2008-02-08 04:20:44 -0800359 else if (dinfo->i_alloc_type == ICBTAG_FLAG_AD_LONG)
Pekka Enberg5ca4e4b2008-10-15 12:28:03 +0200360 epos.offset -= sizeof(struct long_ad);
Marcin Slusarz4b111112008-02-08 04:20:36 -0800361 } else
Linus Torvalds1da177e2005-04-16 15:20:36 -0700362 offset = 0;
363
Marcin Slusarz4b111112008-02-08 04:20:36 -0800364 fibh->sbh = fibh->ebh = udf_tread(dir->i_sb, block);
365 if (!fibh->sbh) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700366 *err = -EIO;
Jan Karab80697c2008-03-04 14:14:05 +0100367 goto out_err;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700368 }
369
Marcin Slusarz48d6d8f2008-02-08 04:20:44 -0800370 block = dinfo->i_location.logicalBlockNum;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700371 }
372
Jan Karaaf793292008-02-08 04:20:50 -0800373 while (f_pos < size) {
Cyrill Gorcunovcb00ea32007-07-19 01:47:43 -0700374 fi = udf_fileident_read(dir, &f_pos, fibh, cfi, &epos, &eloc,
375 &elen, &offset);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700376
Cyrill Gorcunovcb00ea32007-07-19 01:47:43 -0700377 if (!fi) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700378 *err = -EIO;
Jan Karab80697c2008-03-04 14:14:05 +0100379 goto out_err;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700380 }
381
382 liu = le16_to_cpu(cfi->lengthOfImpUse);
383 lfi = cfi->lengthFileIdent;
384
Cyrill Gorcunovcb00ea32007-07-19 01:47:43 -0700385 if ((cfi->fileCharacteristics & FID_FILE_CHAR_DELETED) != 0) {
Marcin Slusarz4b111112008-02-08 04:20:36 -0800386 if (((sizeof(struct fileIdentDesc) +
387 liu + lfi + 3) & ~3) == nfidlen) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700388 cfi->descTag.tagSerialNum = cpu_to_le16(1);
389 cfi->fileVersionNum = cpu_to_le16(1);
390 cfi->fileCharacteristics = 0;
391 cfi->lengthFileIdent = namelen;
392 cfi->lengthOfImpUse = cpu_to_le16(0);
Marcin Slusarz4b111112008-02-08 04:20:36 -0800393 if (!udf_write_fi(dir, cfi, fi, fibh, NULL,
394 name))
Jan Karab80697c2008-03-04 14:14:05 +0100395 goto out_ok;
Marcin Slusarz4b111112008-02-08 04:20:36 -0800396 else {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700397 *err = -EIO;
Jan Karab80697c2008-03-04 14:14:05 +0100398 goto out_err;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700399 }
400 }
401 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700402 }
403
Cyrill Gorcunov28de7942007-07-21 04:37:18 -0700404add:
Linus Torvalds1da177e2005-04-16 15:20:36 -0700405 f_pos += nfidlen;
406
Marcin Slusarz48d6d8f2008-02-08 04:20:44 -0800407 if (dinfo->i_alloc_type == ICBTAG_FLAG_AD_IN_ICB &&
Cyrill Gorcunovcb00ea32007-07-19 01:47:43 -0700408 sb->s_blocksize - fibh->eoffset < nfidlen) {
Jan Kara3bf25cb2007-05-08 00:35:16 -0700409 brelse(epos.bh);
Jan Karaff116fc2007-05-08 00:35:14 -0700410 epos.bh = NULL;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700411 fibh->soffset -= udf_ext0_offset(dir);
412 fibh->eoffset -= udf_ext0_offset(dir);
Jan Karaaf793292008-02-08 04:20:50 -0800413 f_pos -= udf_ext0_offset(dir);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700414 if (fibh->sbh != fibh->ebh)
Jan Kara3bf25cb2007-05-08 00:35:16 -0700415 brelse(fibh->ebh);
416 brelse(fibh->sbh);
Marcin Slusarz4b111112008-02-08 04:20:36 -0800417 fibh->sbh = fibh->ebh =
418 udf_expand_dir_adinicb(dir, &block, err);
419 if (!fibh->sbh)
Jan Karab80697c2008-03-04 14:14:05 +0100420 goto out_err;
Marcin Slusarz48d6d8f2008-02-08 04:20:44 -0800421 epos.block = dinfo->i_location;
Jan Karaff116fc2007-05-08 00:35:14 -0700422 epos.offset = udf_file_entry_alloc_offset(dir);
Jan Kara05343c42008-02-08 04:20:51 -0800423 /* Load extent udf_expand_dir_adinicb() has created */
424 udf_current_aext(dir, &epos, &eloc, &elen, 1);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700425 }
426
Jan Kara2c948b32009-12-03 13:39:28 +0100427 /* Entry fits into current block? */
Cyrill Gorcunovcb00ea32007-07-19 01:47:43 -0700428 if (sb->s_blocksize - fibh->eoffset >= nfidlen) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700429 fibh->soffset = fibh->eoffset;
430 fibh->eoffset += nfidlen;
Cyrill Gorcunovcb00ea32007-07-19 01:47:43 -0700431 if (fibh->sbh != fibh->ebh) {
Jan Kara3bf25cb2007-05-08 00:35:16 -0700432 brelse(fibh->sbh);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700433 fibh->sbh = fibh->ebh;
434 }
435
Marcin Slusarz48d6d8f2008-02-08 04:20:44 -0800436 if (dinfo->i_alloc_type == ICBTAG_FLAG_AD_IN_ICB) {
437 block = dinfo->i_location.logicalBlockNum;
Marcin Slusarz4b111112008-02-08 04:20:36 -0800438 fi = (struct fileIdentDesc *)
Marcin Slusarz48d6d8f2008-02-08 04:20:44 -0800439 (dinfo->i_ext.i_data +
Marcin Slusarzc0b34432008-02-08 04:20:42 -0800440 fibh->soffset -
Marcin Slusarz4b111112008-02-08 04:20:36 -0800441 udf_ext0_offset(dir) +
Marcin Slusarz48d6d8f2008-02-08 04:20:44 -0800442 dinfo->i_lenEAttr);
Cyrill Gorcunovcb00ea32007-07-19 01:47:43 -0700443 } else {
Marcin Slusarz4b111112008-02-08 04:20:36 -0800444 block = eloc.logicalBlockNum +
445 ((elen - 1) >>
446 dir->i_sb->s_blocksize_bits);
447 fi = (struct fileIdentDesc *)
448 (fibh->sbh->b_data + fibh->soffset);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700449 }
Cyrill Gorcunovcb00ea32007-07-19 01:47:43 -0700450 } else {
Jan Kara2c948b32009-12-03 13:39:28 +0100451 /* Round up last extent in the file */
452 elen = (elen + sb->s_blocksize - 1) & ~(sb->s_blocksize - 1);
453 if (dinfo->i_alloc_type == ICBTAG_FLAG_AD_SHORT)
454 epos.offset -= sizeof(struct short_ad);
455 else if (dinfo->i_alloc_type == ICBTAG_FLAG_AD_LONG)
456 epos.offset -= sizeof(struct long_ad);
457 udf_write_aext(dir, &epos, &eloc, elen, 1);
458 dinfo->i_lenExtents = (dinfo->i_lenExtents + sb->s_blocksize
459 - 1) & ~(sb->s_blocksize - 1);
460
Linus Torvalds1da177e2005-04-16 15:20:36 -0700461 fibh->soffset = fibh->eoffset - sb->s_blocksize;
462 fibh->eoffset += nfidlen - sb->s_blocksize;
Cyrill Gorcunovcb00ea32007-07-19 01:47:43 -0700463 if (fibh->sbh != fibh->ebh) {
Jan Kara3bf25cb2007-05-08 00:35:16 -0700464 brelse(fibh->sbh);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700465 fibh->sbh = fibh->ebh;
466 }
467
468 block = eloc.logicalBlockNum + ((elen - 1) >>
Cyrill Gorcunovcb00ea32007-07-19 01:47:43 -0700469 dir->i_sb->s_blocksize_bits);
Marcin Slusarz4b111112008-02-08 04:20:36 -0800470 fibh->ebh = udf_bread(dir,
Jan Karaaf793292008-02-08 04:20:50 -0800471 f_pos >> dir->i_sb->s_blocksize_bits, 1, err);
Jan Karab80697c2008-03-04 14:14:05 +0100472 if (!fibh->ebh)
473 goto out_err;
Jan Kara4651c592010-11-25 03:56:24 +0100474 /* Extents could have been merged, invalidate our position */
475 brelse(epos.bh);
476 epos.bh = NULL;
477 epos.block = dinfo->i_location;
478 epos.offset = udf_file_entry_alloc_offset(dir);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700479
Cyrill Gorcunov28de7942007-07-21 04:37:18 -0700480 if (!fibh->soffset) {
Jan Kara4651c592010-11-25 03:56:24 +0100481 /* Find the freshly allocated block */
482 while (udf_next_aext(dir, &epos, &eloc, &elen, 1) ==
483 (EXT_RECORDED_ALLOCATED >> 30))
484 ;
485 block = eloc.logicalBlockNum + ((elen - 1) >>
Cyrill Gorcunov28de7942007-07-21 04:37:18 -0700486 dir->i_sb->s_blocksize_bits);
Jan Kara3bf25cb2007-05-08 00:35:16 -0700487 brelse(fibh->sbh);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700488 fibh->sbh = fibh->ebh;
489 fi = (struct fileIdentDesc *)(fibh->sbh->b_data);
Cyrill Gorcunovcb00ea32007-07-19 01:47:43 -0700490 } else {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700491 fi = (struct fileIdentDesc *)
Marcin Slusarz4b111112008-02-08 04:20:36 -0800492 (fibh->sbh->b_data + sb->s_blocksize +
493 fibh->soffset);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700494 }
495 }
496
497 memset(cfi, 0, sizeof(struct fileIdentDesc));
Marcin Slusarz6c79e982008-02-08 04:20:30 -0800498 if (UDF_SB(sb)->s_udfrev >= 0x0200)
Marcin Slusarz4b111112008-02-08 04:20:36 -0800499 udf_new_tag((char *)cfi, TAG_IDENT_FID, 3, 1, block,
Pekka Enberg5ca4e4b2008-10-15 12:28:03 +0200500 sizeof(struct tag));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700501 else
Marcin Slusarz4b111112008-02-08 04:20:36 -0800502 udf_new_tag((char *)cfi, TAG_IDENT_FID, 2, 1, block,
Pekka Enberg5ca4e4b2008-10-15 12:28:03 +0200503 sizeof(struct tag));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700504 cfi->fileVersionNum = cpu_to_le16(1);
505 cfi->lengthFileIdent = namelen;
506 cfi->lengthOfImpUse = cpu_to_le16(0);
Cyrill Gorcunovcb00ea32007-07-19 01:47:43 -0700507 if (!udf_write_fi(dir, cfi, fi, fibh, NULL, name)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700508 dir->i_size += nfidlen;
Marcin Slusarz48d6d8f2008-02-08 04:20:44 -0800509 if (dinfo->i_alloc_type == ICBTAG_FLAG_AD_IN_ICB)
510 dinfo->i_lenAlloc += nfidlen;
Jan Kara2c948b32009-12-03 13:39:28 +0100511 else {
512 /* Find the last extent and truncate it to proper size */
513 while (udf_next_aext(dir, &epos, &eloc, &elen, 1) ==
514 (EXT_RECORDED_ALLOCATED >> 30))
515 ;
516 elen -= dinfo->i_lenExtents - dir->i_size;
517 if (dinfo->i_alloc_type == ICBTAG_FLAG_AD_SHORT)
518 epos.offset -= sizeof(struct short_ad);
519 else if (dinfo->i_alloc_type == ICBTAG_FLAG_AD_LONG)
520 epos.offset -= sizeof(struct long_ad);
521 udf_write_aext(dir, &epos, &eloc, elen, 1);
522 dinfo->i_lenExtents = dir->i_size;
523 }
524
Linus Torvalds1da177e2005-04-16 15:20:36 -0700525 mark_inode_dirty(dir);
Jan Karab80697c2008-03-04 14:14:05 +0100526 goto out_ok;
Cyrill Gorcunovcb00ea32007-07-19 01:47:43 -0700527 } else {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700528 *err = -EIO;
Jan Karab80697c2008-03-04 14:14:05 +0100529 goto out_err;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700530 }
Jan Karab80697c2008-03-04 14:14:05 +0100531
532out_err:
533 fi = NULL;
534 if (fibh->sbh != fibh->ebh)
535 brelse(fibh->ebh);
536 brelse(fibh->sbh);
537out_ok:
538 brelse(epos.bh);
539 kfree(name);
540 return fi;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700541}
542
543static int udf_delete_entry(struct inode *inode, struct fileIdentDesc *fi,
Cyrill Gorcunovcb00ea32007-07-19 01:47:43 -0700544 struct udf_fileident_bh *fibh,
545 struct fileIdentDesc *cfi)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700546{
547 cfi->fileCharacteristics |= FID_FILE_CHAR_DELETED;
Cyrill Gorcunov28de7942007-07-21 04:37:18 -0700548
Linus Torvalds1da177e2005-04-16 15:20:36 -0700549 if (UDF_QUERY_FLAG(inode->i_sb, UDF_FLAG_STRICT))
Pekka Enberg5ca4e4b2008-10-15 12:28:03 +0200550 memset(&(cfi->icb), 0x00, sizeof(struct long_ad));
Cyrill Gorcunov28de7942007-07-21 04:37:18 -0700551
Linus Torvalds1da177e2005-04-16 15:20:36 -0700552 return udf_write_fi(inode, cfi, fi, fibh, NULL, NULL);
553}
554
Cyrill Gorcunovcb00ea32007-07-19 01:47:43 -0700555static int udf_create(struct inode *dir, struct dentry *dentry, int mode,
556 struct nameidata *nd)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700557{
558 struct udf_fileident_bh fibh;
559 struct inode *inode;
560 struct fileIdentDesc cfi, *fi;
561 int err;
Marcin Slusarz48d6d8f2008-02-08 04:20:44 -0800562 struct udf_inode_info *iinfo;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700563
Linus Torvalds1da177e2005-04-16 15:20:36 -0700564 inode = udf_new_inode(dir, mode, &err);
Cyrill Gorcunovcb00ea32007-07-19 01:47:43 -0700565 if (!inode) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700566 return err;
567 }
568
Marcin Slusarz48d6d8f2008-02-08 04:20:44 -0800569 iinfo = UDF_I(inode);
570 if (iinfo->i_alloc_type == ICBTAG_FLAG_AD_IN_ICB)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700571 inode->i_data.a_ops = &udf_adinicb_aops;
572 else
573 inode->i_data.a_ops = &udf_aops;
574 inode->i_op = &udf_file_inode_operations;
575 inode->i_fop = &udf_file_operations;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700576 mark_inode_dirty(inode);
577
Marcin Slusarz4b111112008-02-08 04:20:36 -0800578 fi = udf_add_entry(dir, dentry, &fibh, &cfi, &err);
579 if (!fi) {
Miklos Szeredi6d6b77f2011-10-28 14:13:28 +0200580 inode_dec_link_count(inode);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700581 iput(inode);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700582 return err;
583 }
584 cfi.icb.extLength = cpu_to_le32(inode->i_sb->s_blocksize);
Marcin Slusarz48d6d8f2008-02-08 04:20:44 -0800585 cfi.icb.extLocation = cpu_to_lelb(iinfo->i_location);
Cyrill Gorcunov28de7942007-07-21 04:37:18 -0700586 *(__le32 *)((struct allocDescImpUse *)cfi.icb.impUse)->impUse =
Marcin Slusarz48d6d8f2008-02-08 04:20:44 -0800587 cpu_to_le32(iinfo->i_unique & 0x00000000FFFFFFFFUL);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700588 udf_write_fi(dir, &cfi, fi, &fibh, NULL, NULL);
Marcin Slusarzc0b34432008-02-08 04:20:42 -0800589 if (UDF_I(dir)->i_alloc_type == ICBTAG_FLAG_AD_IN_ICB)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700590 mark_inode_dirty(dir);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700591 if (fibh.sbh != fibh.ebh)
Jan Kara3bf25cb2007-05-08 00:35:16 -0700592 brelse(fibh.ebh);
593 brelse(fibh.sbh);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700594 d_instantiate(dentry, inode);
Cyrill Gorcunov28de7942007-07-21 04:37:18 -0700595
Linus Torvalds1da177e2005-04-16 15:20:36 -0700596 return 0;
597}
598
Cyrill Gorcunovcb00ea32007-07-19 01:47:43 -0700599static int udf_mknod(struct inode *dir, struct dentry *dentry, int mode,
600 dev_t rdev)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700601{
Cyrill Gorcunovcb00ea32007-07-19 01:47:43 -0700602 struct inode *inode;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700603 struct udf_fileident_bh fibh;
604 struct fileIdentDesc cfi, *fi;
605 int err;
Marcin Slusarz48d6d8f2008-02-08 04:20:44 -0800606 struct udf_inode_info *iinfo;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700607
608 if (!old_valid_dev(rdev))
609 return -EINVAL;
610
Linus Torvalds1da177e2005-04-16 15:20:36 -0700611 err = -EIO;
612 inode = udf_new_inode(dir, mode, &err);
613 if (!inode)
614 goto out;
615
Marcin Slusarz48d6d8f2008-02-08 04:20:44 -0800616 iinfo = UDF_I(inode);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700617 init_special_inode(inode, mode, rdev);
Marcin Slusarz4b111112008-02-08 04:20:36 -0800618 fi = udf_add_entry(dir, dentry, &fibh, &cfi, &err);
619 if (!fi) {
Miklos Szeredi6d6b77f2011-10-28 14:13:28 +0200620 inode_dec_link_count(inode);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700621 iput(inode);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700622 return err;
623 }
624 cfi.icb.extLength = cpu_to_le32(inode->i_sb->s_blocksize);
Marcin Slusarz48d6d8f2008-02-08 04:20:44 -0800625 cfi.icb.extLocation = cpu_to_lelb(iinfo->i_location);
Cyrill Gorcunov28de7942007-07-21 04:37:18 -0700626 *(__le32 *)((struct allocDescImpUse *)cfi.icb.impUse)->impUse =
Marcin Slusarz48d6d8f2008-02-08 04:20:44 -0800627 cpu_to_le32(iinfo->i_unique & 0x00000000FFFFFFFFUL);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700628 udf_write_fi(dir, &cfi, fi, &fibh, NULL, NULL);
Marcin Slusarzc0b34432008-02-08 04:20:42 -0800629 if (UDF_I(dir)->i_alloc_type == ICBTAG_FLAG_AD_IN_ICB)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700630 mark_inode_dirty(dir);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700631 mark_inode_dirty(inode);
632
633 if (fibh.sbh != fibh.ebh)
Jan Kara3bf25cb2007-05-08 00:35:16 -0700634 brelse(fibh.ebh);
635 brelse(fibh.sbh);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700636 d_instantiate(dentry, inode);
637 err = 0;
Cyrill Gorcunov28de7942007-07-21 04:37:18 -0700638
639out:
Linus Torvalds1da177e2005-04-16 15:20:36 -0700640 return err;
641}
642
Cyrill Gorcunovcb00ea32007-07-19 01:47:43 -0700643static int udf_mkdir(struct inode *dir, struct dentry *dentry, int mode)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700644{
Cyrill Gorcunovcb00ea32007-07-19 01:47:43 -0700645 struct inode *inode;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700646 struct udf_fileident_bh fibh;
647 struct fileIdentDesc cfi, *fi;
648 int err;
Marcin Slusarz48d6d8f2008-02-08 04:20:44 -0800649 struct udf_inode_info *dinfo = UDF_I(dir);
650 struct udf_inode_info *iinfo;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700651
Linus Torvalds1da177e2005-04-16 15:20:36 -0700652 err = -EMLINK;
Al Viro810c1b2e2011-03-02 10:15:26 -0500653 if (dir->i_nlink >= UDF_MAX_LINKS)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700654 goto out;
655
656 err = -EIO;
Dmitry Monakhova6c5a032010-03-04 17:32:22 +0300657 inode = udf_new_inode(dir, S_IFDIR | mode, &err);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700658 if (!inode)
659 goto out;
660
Marcin Slusarz48d6d8f2008-02-08 04:20:44 -0800661 iinfo = UDF_I(inode);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700662 inode->i_op = &udf_dir_inode_operations;
663 inode->i_fop = &udf_dir_operations;
Marcin Slusarz4b111112008-02-08 04:20:36 -0800664 fi = udf_add_entry(inode, NULL, &fibh, &cfi, &err);
665 if (!fi) {
Miklos Szeredi6d6b77f2011-10-28 14:13:28 +0200666 inode_dec_link_count(inode);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700667 iput(inode);
668 goto out;
669 }
Miklos Szeredibfe86842011-10-28 14:13:29 +0200670 set_nlink(inode, 2);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700671 cfi.icb.extLength = cpu_to_le32(inode->i_sb->s_blocksize);
Marcin Slusarz48d6d8f2008-02-08 04:20:44 -0800672 cfi.icb.extLocation = cpu_to_lelb(dinfo->i_location);
Cyrill Gorcunov28de7942007-07-21 04:37:18 -0700673 *(__le32 *)((struct allocDescImpUse *)cfi.icb.impUse)->impUse =
Marcin Slusarz48d6d8f2008-02-08 04:20:44 -0800674 cpu_to_le32(dinfo->i_unique & 0x00000000FFFFFFFFUL);
Marcin Slusarz4b111112008-02-08 04:20:36 -0800675 cfi.fileCharacteristics =
676 FID_FILE_CHAR_DIRECTORY | FID_FILE_CHAR_PARENT;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700677 udf_write_fi(inode, &cfi, fi, &fibh, NULL, NULL);
Jan Kara3bf25cb2007-05-08 00:35:16 -0700678 brelse(fibh.sbh);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700679 mark_inode_dirty(inode);
680
Marcin Slusarz4b111112008-02-08 04:20:36 -0800681 fi = udf_add_entry(dir, dentry, &fibh, &cfi, &err);
682 if (!fi) {
Miklos Szeredi6d6b77f2011-10-28 14:13:28 +0200683 clear_nlink(inode);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700684 mark_inode_dirty(inode);
685 iput(inode);
686 goto out;
687 }
688 cfi.icb.extLength = cpu_to_le32(inode->i_sb->s_blocksize);
Marcin Slusarz48d6d8f2008-02-08 04:20:44 -0800689 cfi.icb.extLocation = cpu_to_lelb(iinfo->i_location);
Cyrill Gorcunov28de7942007-07-21 04:37:18 -0700690 *(__le32 *)((struct allocDescImpUse *)cfi.icb.impUse)->impUse =
Marcin Slusarz48d6d8f2008-02-08 04:20:44 -0800691 cpu_to_le32(iinfo->i_unique & 0x00000000FFFFFFFFUL);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700692 cfi.fileCharacteristics |= FID_FILE_CHAR_DIRECTORY;
693 udf_write_fi(dir, &cfi, fi, &fibh, NULL, NULL);
Dave Hansend8c76e62006-09-30 23:29:04 -0700694 inc_nlink(dir);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700695 mark_inode_dirty(dir);
696 d_instantiate(dentry, inode);
697 if (fibh.sbh != fibh.ebh)
Jan Kara3bf25cb2007-05-08 00:35:16 -0700698 brelse(fibh.ebh);
699 brelse(fibh.sbh);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700700 err = 0;
Cyrill Gorcunov28de7942007-07-21 04:37:18 -0700701
702out:
Linus Torvalds1da177e2005-04-16 15:20:36 -0700703 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;
Pekka Enberg5ca4e4b2008-10-15 12:28:03 +0200713 struct kernel_lb_addr eloc;
Jan Karaff116fc2007-05-08 00:35:14 -0700714 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)) {
Pekka Enberg97e961f2008-10-15 12:29:03 +0200727 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)
Pekka Enberg5ca4e4b2008-10-15 12:28:03 +0200730 epos.offset -= sizeof(struct short_ad);
Marcin Slusarz48d6d8f2008-02-08 04:20:44 -0800731 else if (dinfo->i_alloc_type == ICBTAG_FLAG_AD_LONG)
Pekka Enberg5ca4e4b2008-10-15 12:28:03 +0200732 epos.offset -= sizeof(struct 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;
Pekka Enberg5ca4e4b2008-10-15 12:28:03 +0200781 struct kernel_lb_addr tloc;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700782
783 retval = -ENOENT;
Al Viro9fbb76c2008-10-12 00:15:17 -0400784 fi = udf_find_entry(dir, &dentry->d_name, &fibh, &cfi);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700785 if (!fi)
786 goto out;
787
788 retval = -EIO;
789 tloc = lelb_to_cpu(cfi.icb.extLocation);
Pekka Enberg97e961f2008-10-15 12:29:03 +0200790 if (udf_get_lb_pblock(dir->i_sb, &tloc, 0) != inode->i_ino)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700791 goto end_rmdir;
792 retval = -ENOTEMPTY;
793 if (!empty_dir(inode))
794 goto end_rmdir;
795 retval = udf_delete_entry(dir, fi, &fibh, &cfi);
796 if (retval)
797 goto end_rmdir;
798 if (inode->i_nlink != 2)
799 udf_warning(inode->i_sb, "udf_rmdir",
Cyrill Gorcunovcb00ea32007-07-19 01:47:43 -0700800 "empty directory has nlink != 2 (%d)",
801 inode->i_nlink);
Dave Hansence71ec32006-09-30 23:29:06 -0700802 clear_nlink(inode);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700803 inode->i_size = 0;
Stephen Mollettc007c062007-05-08 00:31:31 -0700804 inode_dec_link_count(dir);
Marcin Slusarz4b111112008-02-08 04:20:36 -0800805 inode->i_ctime = dir->i_ctime = dir->i_mtime =
806 current_fs_time(dir->i_sb);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700807 mark_inode_dirty(dir);
808
Cyrill Gorcunov28de7942007-07-21 04:37:18 -0700809end_rmdir:
Linus Torvalds1da177e2005-04-16 15:20:36 -0700810 if (fibh.sbh != fibh.ebh)
Jan Kara3bf25cb2007-05-08 00:35:16 -0700811 brelse(fibh.ebh);
812 brelse(fibh.sbh);
Cyrill Gorcunov28de7942007-07-21 04:37:18 -0700813
814out:
Linus Torvalds1da177e2005-04-16 15:20:36 -0700815 return retval;
816}
817
Cyrill Gorcunovcb00ea32007-07-19 01:47:43 -0700818static int udf_unlink(struct inode *dir, struct dentry *dentry)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700819{
820 int retval;
Cyrill Gorcunovcb00ea32007-07-19 01:47:43 -0700821 struct inode *inode = dentry->d_inode;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700822 struct udf_fileident_bh fibh;
823 struct fileIdentDesc *fi;
824 struct fileIdentDesc cfi;
Pekka Enberg5ca4e4b2008-10-15 12:28:03 +0200825 struct kernel_lb_addr tloc;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700826
827 retval = -ENOENT;
Al Viro9fbb76c2008-10-12 00:15:17 -0400828 fi = udf_find_entry(dir, &dentry->d_name, &fibh, &cfi);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700829 if (!fi)
830 goto out;
831
832 retval = -EIO;
833 tloc = lelb_to_cpu(cfi.icb.extLocation);
Pekka Enberg97e961f2008-10-15 12:29:03 +0200834 if (udf_get_lb_pblock(dir->i_sb, &tloc, 0) != inode->i_ino)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700835 goto end_unlink;
836
Cyrill Gorcunovcb00ea32007-07-19 01:47:43 -0700837 if (!inode->i_nlink) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700838 udf_debug("Deleting nonexistent file (%lu), %d\n",
Cyrill Gorcunovcb00ea32007-07-19 01:47:43 -0700839 inode->i_ino, inode->i_nlink);
Miklos Szeredibfe86842011-10-28 14:13:29 +0200840 set_nlink(inode, 1);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700841 }
842 retval = udf_delete_entry(dir, fi, &fibh, &cfi);
843 if (retval)
844 goto end_unlink;
845 dir->i_ctime = dir->i_mtime = current_fs_time(dir->i_sb);
846 mark_inode_dirty(dir);
Dave Hansen9a53c3a2006-09-30 23:29:03 -0700847 inode_dec_link_count(inode);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700848 inode->i_ctime = dir->i_ctime;
849 retval = 0;
850
Cyrill Gorcunov28de7942007-07-21 04:37:18 -0700851end_unlink:
Linus Torvalds1da177e2005-04-16 15:20:36 -0700852 if (fibh.sbh != fibh.ebh)
Jan Kara3bf25cb2007-05-08 00:35:16 -0700853 brelse(fibh.ebh);
854 brelse(fibh.sbh);
Cyrill Gorcunov28de7942007-07-21 04:37:18 -0700855
856out:
Linus Torvalds1da177e2005-04-16 15:20:36 -0700857 return retval;
858}
859
Cyrill Gorcunovcb00ea32007-07-19 01:47:43 -0700860static int udf_symlink(struct inode *dir, struct dentry *dentry,
861 const char *symname)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700862{
Cyrill Gorcunovcb00ea32007-07-19 01:47:43 -0700863 struct inode *inode;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700864 struct pathComponent *pc;
Al Viro391e8bb2010-01-31 21:28:48 -0500865 const char *compstart;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700866 struct udf_fileident_bh fibh;
Cyrill Gorcunov28de7942007-07-21 04:37:18 -0700867 struct extent_position epos = {};
Linus Torvalds1da177e2005-04-16 15:20:36 -0700868 int eoffset, elen = 0;
869 struct fileIdentDesc *fi;
870 struct fileIdentDesc cfi;
Al Viro391e8bb2010-01-31 21:28:48 -0500871 uint8_t *ea;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700872 int err;
873 int block;
Al Viro391e8bb2010-01-31 21:28:48 -0500874 unsigned char *name = NULL;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700875 int namelen;
Marcin Slusarz48d6d8f2008-02-08 04:20:44 -0800876 struct udf_inode_info *iinfo;
Jan Karad664b6a2010-10-20 18:28:46 +0200877 struct super_block *sb = dir->i_sb;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700878
Dmitry Monakhova6c5a032010-03-04 17:32:22 +0300879 inode = udf_new_inode(dir, S_IFLNK | S_IRWXUGO, &err);
Marcin Slusarz4b111112008-02-08 04:20:36 -0800880 if (!inode)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700881 goto out;
882
Alessio Igor Bogani4d0fb622010-11-16 18:40:47 +0100883 iinfo = UDF_I(inode);
884 down_write(&iinfo->i_data_sem);
Jan Karab80697c2008-03-04 14:14:05 +0100885 name = kmalloc(UDF_NAME_LEN, GFP_NOFS);
886 if (!name) {
887 err = -ENOMEM;
888 goto out_no_entry;
889 }
890
Linus Torvalds1da177e2005-04-16 15:20:36 -0700891 inode->i_data.a_ops = &udf_symlink_aops;
Dmitry Monakhovc15d0fc2010-03-29 11:05:21 +0400892 inode->i_op = &udf_symlink_inode_operations;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700893
Marcin Slusarz48d6d8f2008-02-08 04:20:44 -0800894 if (iinfo->i_alloc_type != ICBTAG_FLAG_AD_IN_ICB) {
Pekka Enberg5ca4e4b2008-10-15 12:28:03 +0200895 struct kernel_lb_addr eloc;
Harvey Harrison78e917d2008-04-28 02:16:19 -0700896 uint32_t bsize;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700897
Jan Karad664b6a2010-10-20 18:28:46 +0200898 block = udf_new_block(sb, inode,
Marcin Slusarz48d6d8f2008-02-08 04:20:44 -0800899 iinfo->i_location.partitionReferenceNum,
900 iinfo->i_location.logicalBlockNum, &err);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700901 if (!block)
902 goto out_no_entry;
Marcin Slusarz48d6d8f2008-02-08 04:20:44 -0800903 epos.block = iinfo->i_location;
Jan Karaff116fc2007-05-08 00:35:14 -0700904 epos.offset = udf_file_entry_alloc_offset(inode);
905 epos.bh = NULL;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700906 eloc.logicalBlockNum = block;
Marcin Slusarz4b111112008-02-08 04:20:36 -0800907 eloc.partitionReferenceNum =
Marcin Slusarz48d6d8f2008-02-08 04:20:44 -0800908 iinfo->i_location.partitionReferenceNum;
Jan Karad664b6a2010-10-20 18:28:46 +0200909 bsize = sb->s_blocksize;
Harvey Harrison78e917d2008-04-28 02:16:19 -0700910 iinfo->i_lenExtents = bsize;
Pekka Enberg97e961f2008-10-15 12:29:03 +0200911 udf_add_aext(inode, &epos, &eloc, bsize, 0);
Jan Kara3bf25cb2007-05-08 00:35:16 -0700912 brelse(epos.bh);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700913
Jan Karad664b6a2010-10-20 18:28:46 +0200914 block = udf_get_pblock(sb, block,
Marcin Slusarz48d6d8f2008-02-08 04:20:44 -0800915 iinfo->i_location.partitionReferenceNum,
Marcin Slusarz4b111112008-02-08 04:20:36 -0800916 0);
Jan Karad664b6a2010-10-20 18:28:46 +0200917 epos.bh = udf_tgetblk(sb, block);
Jan Karaff116fc2007-05-08 00:35:14 -0700918 lock_buffer(epos.bh);
Jan Karad664b6a2010-10-20 18:28:46 +0200919 memset(epos.bh->b_data, 0x00, bsize);
Jan Karaff116fc2007-05-08 00:35:14 -0700920 set_buffer_uptodate(epos.bh);
921 unlock_buffer(epos.bh);
922 mark_buffer_dirty_inode(epos.bh, inode);
923 ea = epos.bh->b_data + udf_ext0_offset(inode);
Marcin Slusarz48d6d8f2008-02-08 04:20:44 -0800924 } else
925 ea = iinfo->i_ext.i_data + iinfo->i_lenEAttr;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700926
Jan Karad664b6a2010-10-20 18:28:46 +0200927 eoffset = sb->s_blocksize - udf_ext0_offset(inode);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700928 pc = (struct pathComponent *)ea;
929
Cyrill Gorcunovcb00ea32007-07-19 01:47:43 -0700930 if (*symname == '/') {
931 do {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700932 symname++;
933 } while (*symname == '/');
934
935 pc->componentType = 1;
936 pc->lengthComponentIdent = 0;
937 pc->componentFileVersionNum = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700938 elen += sizeof(struct pathComponent);
939 }
940
941 err = -ENAMETOOLONG;
942
Cyrill Gorcunovcb00ea32007-07-19 01:47:43 -0700943 while (*symname) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700944 if (elen + sizeof(struct pathComponent) > eoffset)
945 goto out_no_entry;
946
947 pc = (struct pathComponent *)(ea + elen);
948
Al Viro391e8bb2010-01-31 21:28:48 -0500949 compstart = symname;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700950
Cyrill Gorcunovcb00ea32007-07-19 01:47:43 -0700951 do {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700952 symname++;
953 } while (*symname && *symname != '/');
954
955 pc->componentType = 5;
956 pc->lengthComponentIdent = 0;
957 pc->componentFileVersionNum = 0;
Cyrill Gorcunovcb00ea32007-07-19 01:47:43 -0700958 if (compstart[0] == '.') {
959 if ((symname - compstart) == 1)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700960 pc->componentType = 4;
Marcin Slusarz4b111112008-02-08 04:20:36 -0800961 else if ((symname - compstart) == 2 &&
962 compstart[1] == '.')
Linus Torvalds1da177e2005-04-16 15:20:36 -0700963 pc->componentType = 3;
964 }
965
Cyrill Gorcunovcb00ea32007-07-19 01:47:43 -0700966 if (pc->componentType == 5) {
Jan Karad664b6a2010-10-20 18:28:46 +0200967 namelen = udf_put_filename(sb, compstart, name,
Cyrill Gorcunov28de7942007-07-21 04:37:18 -0700968 symname - compstart);
969 if (!namelen)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700970 goto out_no_entry;
971
Marcin Slusarz4b111112008-02-08 04:20:36 -0800972 if (elen + sizeof(struct pathComponent) + namelen >
973 eoffset)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700974 goto out_no_entry;
975 else
976 pc->lengthComponentIdent = namelen;
977
978 memcpy(pc->componentIdent, name, namelen);
979 }
980
981 elen += sizeof(struct pathComponent) + pc->lengthComponentIdent;
982
Cyrill Gorcunovcb00ea32007-07-19 01:47:43 -0700983 if (*symname) {
984 do {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700985 symname++;
986 } while (*symname == '/');
987 }
988 }
989
Jan Kara3bf25cb2007-05-08 00:35:16 -0700990 brelse(epos.bh);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700991 inode->i_size = elen;
Marcin Slusarz48d6d8f2008-02-08 04:20:44 -0800992 if (iinfo->i_alloc_type == ICBTAG_FLAG_AD_IN_ICB)
993 iinfo->i_lenAlloc = inode->i_size;
Jan Kara2c948b32009-12-03 13:39:28 +0100994 else
995 udf_truncate_tail_extent(inode);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700996 mark_inode_dirty(inode);
997
Marcin Slusarz4b111112008-02-08 04:20:36 -0800998 fi = udf_add_entry(dir, dentry, &fibh, &cfi, &err);
999 if (!fi)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001000 goto out_no_entry;
Jan Karad664b6a2010-10-20 18:28:46 +02001001 cfi.icb.extLength = cpu_to_le32(sb->s_blocksize);
Marcin Slusarz48d6d8f2008-02-08 04:20:44 -08001002 cfi.icb.extLocation = cpu_to_lelb(iinfo->i_location);
Jan Karad664b6a2010-10-20 18:28:46 +02001003 if (UDF_SB(inode->i_sb)->s_lvid_bh) {
Cyrill Gorcunov28de7942007-07-21 04:37:18 -07001004 *(__le32 *)((struct allocDescImpUse *)cfi.icb.impUse)->impUse =
Jan Karad664b6a2010-10-20 18:28:46 +02001005 cpu_to_le32(lvid_get_unique_id(sb));
Linus Torvalds1da177e2005-04-16 15:20:36 -07001006 }
1007 udf_write_fi(dir, &cfi, fi, &fibh, NULL, NULL);
Marcin Slusarzc0b34432008-02-08 04:20:42 -08001008 if (UDF_I(dir)->i_alloc_type == ICBTAG_FLAG_AD_IN_ICB)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001009 mark_inode_dirty(dir);
Alessio Igor Bogani4d0fb622010-11-16 18:40:47 +01001010 up_write(&iinfo->i_data_sem);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001011 if (fibh.sbh != fibh.ebh)
Jan Kara3bf25cb2007-05-08 00:35:16 -07001012 brelse(fibh.ebh);
1013 brelse(fibh.sbh);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001014 d_instantiate(dentry, inode);
1015 err = 0;
1016
Cyrill Gorcunov28de7942007-07-21 04:37:18 -07001017out:
Jan Karab80697c2008-03-04 14:14:05 +01001018 kfree(name);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001019 return err;
1020
Cyrill Gorcunov28de7942007-07-21 04:37:18 -07001021out_no_entry:
Alessio Igor Bogani4d0fb622010-11-16 18:40:47 +01001022 up_write(&iinfo->i_data_sem);
Dave Hansen9a53c3a2006-09-30 23:29:03 -07001023 inode_dec_link_count(inode);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001024 iput(inode);
1025 goto out;
1026}
1027
Cyrill Gorcunovcb00ea32007-07-19 01:47:43 -07001028static int udf_link(struct dentry *old_dentry, struct inode *dir,
1029 struct dentry *dentry)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001030{
1031 struct inode *inode = old_dentry->d_inode;
1032 struct udf_fileident_bh fibh;
1033 struct fileIdentDesc cfi, *fi;
1034 int err;
1035
Al Viro810c1b2e2011-03-02 10:15:26 -05001036 if (inode->i_nlink >= UDF_MAX_LINKS)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001037 return -EMLINK;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001038
Marcin Slusarz4b111112008-02-08 04:20:36 -08001039 fi = udf_add_entry(dir, dentry, &fibh, &cfi, &err);
1040 if (!fi) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001041 return err;
1042 }
1043 cfi.icb.extLength = cpu_to_le32(inode->i_sb->s_blocksize);
Marcin Slusarzc0b34432008-02-08 04:20:42 -08001044 cfi.icb.extLocation = cpu_to_lelb(UDF_I(inode)->i_location);
Jan Karad664b6a2010-10-20 18:28:46 +02001045 if (UDF_SB(inode->i_sb)->s_lvid_bh) {
Cyrill Gorcunov28de7942007-07-21 04:37:18 -07001046 *(__le32 *)((struct allocDescImpUse *)cfi.icb.impUse)->impUse =
Jan Karad664b6a2010-10-20 18:28:46 +02001047 cpu_to_le32(lvid_get_unique_id(inode->i_sb));
Linus Torvalds1da177e2005-04-16 15:20:36 -07001048 }
1049 udf_write_fi(dir, &cfi, fi, &fibh, NULL, NULL);
Marcin Slusarzc0b34432008-02-08 04:20:42 -08001050 if (UDF_I(dir)->i_alloc_type == ICBTAG_FLAG_AD_IN_ICB)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001051 mark_inode_dirty(dir);
Cyrill Gorcunov28de7942007-07-21 04:37:18 -07001052
Linus Torvalds1da177e2005-04-16 15:20:36 -07001053 if (fibh.sbh != fibh.ebh)
Jan Kara3bf25cb2007-05-08 00:35:16 -07001054 brelse(fibh.ebh);
1055 brelse(fibh.sbh);
Dave Hansend8c76e62006-09-30 23:29:04 -07001056 inc_nlink(inode);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001057 inode->i_ctime = current_fs_time(inode->i_sb);
1058 mark_inode_dirty(inode);
Al Viro7de9c6ee2010-10-23 11:11:40 -04001059 ihold(inode);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001060 d_instantiate(dentry, inode);
Cyrill Gorcunov28de7942007-07-21 04:37:18 -07001061
Linus Torvalds1da177e2005-04-16 15:20:36 -07001062 return 0;
1063}
1064
1065/* Anybody can rename anything with this: the permission checks are left to the
1066 * higher-level routines.
1067 */
Cyrill Gorcunovcb00ea32007-07-19 01:47:43 -07001068static int udf_rename(struct inode *old_dir, struct dentry *old_dentry,
1069 struct inode *new_dir, struct dentry *new_dentry)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001070{
Cyrill Gorcunovcb00ea32007-07-19 01:47:43 -07001071 struct inode *old_inode = old_dentry->d_inode;
1072 struct inode *new_inode = new_dentry->d_inode;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001073 struct udf_fileident_bh ofibh, nfibh;
Marcin Slusarz4b111112008-02-08 04:20:36 -08001074 struct fileIdentDesc *ofi = NULL, *nfi = NULL, *dir_fi = NULL;
1075 struct fileIdentDesc ocfi, ncfi;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001076 struct buffer_head *dir_bh = NULL;
1077 int retval = -ENOENT;
Pekka Enberg5ca4e4b2008-10-15 12:28:03 +02001078 struct kernel_lb_addr tloc;
Marcin Slusarz48d6d8f2008-02-08 04:20:44 -08001079 struct udf_inode_info *old_iinfo = UDF_I(old_inode);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001080
Al Viro9fbb76c2008-10-12 00:15:17 -04001081 ofi = udf_find_entry(old_dir, &old_dentry->d_name, &ofibh, &ocfi);
Marcin Slusarz4b111112008-02-08 04:20:36 -08001082 if (ofi) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001083 if (ofibh.sbh != ofibh.ebh)
Jan Kara3bf25cb2007-05-08 00:35:16 -07001084 brelse(ofibh.ebh);
1085 brelse(ofibh.sbh);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001086 }
1087 tloc = lelb_to_cpu(ocfi.icb.extLocation);
Pekka Enberg97e961f2008-10-15 12:29:03 +02001088 if (!ofi || udf_get_lb_pblock(old_dir->i_sb, &tloc, 0)
Cyrill Gorcunovcb00ea32007-07-19 01:47:43 -07001089 != old_inode->i_ino)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001090 goto end_rename;
1091
Al Viro9fbb76c2008-10-12 00:15:17 -04001092 nfi = udf_find_entry(new_dir, &new_dentry->d_name, &nfibh, &ncfi);
Cyrill Gorcunovcb00ea32007-07-19 01:47:43 -07001093 if (nfi) {
1094 if (!new_inode) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001095 if (nfibh.sbh != nfibh.ebh)
Jan Kara3bf25cb2007-05-08 00:35:16 -07001096 brelse(nfibh.ebh);
1097 brelse(nfibh.sbh);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001098 nfi = NULL;
1099 }
1100 }
Cyrill Gorcunovcb00ea32007-07-19 01:47:43 -07001101 if (S_ISDIR(old_inode->i_mode)) {
Marcin Slusarz7f3fbd02008-02-08 04:20:49 -08001102 int offset = udf_ext0_offset(old_inode);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001103
Cyrill Gorcunovcb00ea32007-07-19 01:47:43 -07001104 if (new_inode) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001105 retval = -ENOTEMPTY;
1106 if (!empty_dir(new_inode))
1107 goto end_rename;
1108 }
1109 retval = -EIO;
Marcin Slusarz48d6d8f2008-02-08 04:20:44 -08001110 if (old_iinfo->i_alloc_type == ICBTAG_FLAG_AD_IN_ICB) {
Marcin Slusarz4b111112008-02-08 04:20:36 -08001111 dir_fi = udf_get_fileident(
Marcin Slusarz48d6d8f2008-02-08 04:20:44 -08001112 old_iinfo->i_ext.i_data -
1113 (old_iinfo->i_efe ?
Marcin Slusarz4b111112008-02-08 04:20:36 -08001114 sizeof(struct extendedFileEntry) :
1115 sizeof(struct fileEntry)),
1116 old_inode->i_sb->s_blocksize, &offset);
Cyrill Gorcunovcb00ea32007-07-19 01:47:43 -07001117 } else {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001118 dir_bh = udf_bread(old_inode, 0, 0, &retval);
1119 if (!dir_bh)
1120 goto end_rename;
Marcin Slusarz4b111112008-02-08 04:20:36 -08001121 dir_fi = udf_get_fileident(dir_bh->b_data,
1122 old_inode->i_sb->s_blocksize, &offset);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001123 }
1124 if (!dir_fi)
1125 goto end_rename;
1126 tloc = lelb_to_cpu(dir_fi->icb.extLocation);
Pekka Enberg97e961f2008-10-15 12:29:03 +02001127 if (udf_get_lb_pblock(old_inode->i_sb, &tloc, 0) !=
Marcin Slusarz4b111112008-02-08 04:20:36 -08001128 old_dir->i_ino)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001129 goto end_rename;
1130
1131 retval = -EMLINK;
Al Viro810c1b2e2011-03-02 10:15:26 -05001132 if (!new_inode && new_dir->i_nlink >= UDF_MAX_LINKS)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001133 goto end_rename;
1134 }
Cyrill Gorcunovcb00ea32007-07-19 01:47:43 -07001135 if (!nfi) {
Marcin Slusarz4b111112008-02-08 04:20:36 -08001136 nfi = udf_add_entry(new_dir, new_dentry, &nfibh, &ncfi,
1137 &retval);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001138 if (!nfi)
1139 goto end_rename;
1140 }
1141
1142 /*
1143 * Like most other Unix systems, set the ctime for inodes on a
1144 * rename.
1145 */
1146 old_inode->i_ctime = current_fs_time(old_inode->i_sb);
1147 mark_inode_dirty(old_inode);
1148
1149 /*
1150 * ok, that's it
1151 */
1152 ncfi.fileVersionNum = ocfi.fileVersionNum;
1153 ncfi.fileCharacteristics = ocfi.fileCharacteristics;
Pekka Enberg5ca4e4b2008-10-15 12:28:03 +02001154 memcpy(&(ncfi.icb), &(ocfi.icb), sizeof(struct long_ad));
Linus Torvalds1da177e2005-04-16 15:20:36 -07001155 udf_write_fi(new_dir, &ncfi, nfi, &nfibh, NULL, NULL);
1156
1157 /* The old fid may have moved - find it again */
Al Viro9fbb76c2008-10-12 00:15:17 -04001158 ofi = udf_find_entry(old_dir, &old_dentry->d_name, &ofibh, &ocfi);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001159 udf_delete_entry(old_dir, ofi, &ofibh, &ocfi);
1160
Cyrill Gorcunovcb00ea32007-07-19 01:47:43 -07001161 if (new_inode) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001162 new_inode->i_ctime = current_fs_time(new_inode->i_sb);
Dave Hansen9a53c3a2006-09-30 23:29:03 -07001163 inode_dec_link_count(new_inode);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001164 }
1165 old_dir->i_ctime = old_dir->i_mtime = current_fs_time(old_dir->i_sb);
1166 mark_inode_dirty(old_dir);
1167
Cyrill Gorcunovcb00ea32007-07-19 01:47:43 -07001168 if (dir_fi) {
Marcin Slusarzc0b34432008-02-08 04:20:42 -08001169 dir_fi->icb.extLocation = cpu_to_lelb(UDF_I(new_dir)->i_location);
Marcin Slusarz4b111112008-02-08 04:20:36 -08001170 udf_update_tag((char *)dir_fi,
1171 (sizeof(struct fileIdentDesc) +
1172 le16_to_cpu(dir_fi->lengthOfImpUse) + 3) & ~3);
Marcin Slusarz48d6d8f2008-02-08 04:20:44 -08001173 if (old_iinfo->i_alloc_type == ICBTAG_FLAG_AD_IN_ICB)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001174 mark_inode_dirty(old_inode);
Marcin Slusarz4b111112008-02-08 04:20:36 -08001175 else
Linus Torvalds1da177e2005-04-16 15:20:36 -07001176 mark_buffer_dirty_inode(dir_bh, old_inode);
Marcin Slusarz4b111112008-02-08 04:20:36 -08001177
Dave Hansen9a53c3a2006-09-30 23:29:03 -07001178 inode_dec_link_count(old_dir);
Marcin Slusarz4b111112008-02-08 04:20:36 -08001179 if (new_inode)
Dave Hansen9a53c3a2006-09-30 23:29:03 -07001180 inode_dec_link_count(new_inode);
Marcin Slusarz4b111112008-02-08 04:20:36 -08001181 else {
Dave Hansend8c76e62006-09-30 23:29:04 -07001182 inc_nlink(new_dir);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001183 mark_inode_dirty(new_dir);
1184 }
1185 }
1186
Cyrill Gorcunovcb00ea32007-07-19 01:47:43 -07001187 if (ofi) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001188 if (ofibh.sbh != ofibh.ebh)
Jan Kara3bf25cb2007-05-08 00:35:16 -07001189 brelse(ofibh.ebh);
1190 brelse(ofibh.sbh);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001191 }
1192
1193 retval = 0;
1194
Cyrill Gorcunov28de7942007-07-21 04:37:18 -07001195end_rename:
Jan Kara3bf25cb2007-05-08 00:35:16 -07001196 brelse(dir_bh);
Cyrill Gorcunovcb00ea32007-07-19 01:47:43 -07001197 if (nfi) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001198 if (nfibh.sbh != nfibh.ebh)
Jan Kara3bf25cb2007-05-08 00:35:16 -07001199 brelse(nfibh.ebh);
1200 brelse(nfibh.sbh);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001201 }
Cyrill Gorcunov28de7942007-07-21 04:37:18 -07001202
Linus Torvalds1da177e2005-04-16 15:20:36 -07001203 return retval;
1204}
1205
Rasmus Rohde221e5832008-04-30 17:22:06 +02001206static struct dentry *udf_get_parent(struct dentry *child)
1207{
Pekka Enberg97e961f2008-10-15 12:29:03 +02001208 struct kernel_lb_addr tloc;
Rasmus Rohde221e5832008-04-30 17:22:06 +02001209 struct inode *inode = NULL;
Al Viro9fbb76c2008-10-12 00:15:17 -04001210 struct qstr dotdot = {.name = "..", .len = 2};
Rasmus Rohde221e5832008-04-30 17:22:06 +02001211 struct fileIdentDesc cfi;
1212 struct udf_fileident_bh fibh;
1213
Rasmus Rohde221e5832008-04-30 17:22:06 +02001214 if (!udf_find_entry(child->d_inode, &dotdot, &fibh, &cfi))
1215 goto out_unlock;
1216
1217 if (fibh.sbh != fibh.ebh)
1218 brelse(fibh.ebh);
1219 brelse(fibh.sbh);
1220
Pekka Enberg97e961f2008-10-15 12:29:03 +02001221 tloc = lelb_to_cpu(cfi.icb.extLocation);
1222 inode = udf_iget(child->d_inode->i_sb, &tloc);
Rasmus Rohde221e5832008-04-30 17:22:06 +02001223 if (!inode)
1224 goto out_unlock;
Rasmus Rohde221e5832008-04-30 17:22:06 +02001225
Christoph Hellwig44003722008-08-11 15:49:04 +02001226 return d_obtain_alias(inode);
Rasmus Rohde221e5832008-04-30 17:22:06 +02001227out_unlock:
Rasmus Rohde221e5832008-04-30 17:22:06 +02001228 return ERR_PTR(-EACCES);
1229}
1230
1231
1232static struct dentry *udf_nfs_get_inode(struct super_block *sb, u32 block,
1233 u16 partref, __u32 generation)
1234{
1235 struct inode *inode;
Pekka Enberg5ca4e4b2008-10-15 12:28:03 +02001236 struct kernel_lb_addr loc;
Rasmus Rohde221e5832008-04-30 17:22:06 +02001237
1238 if (block == 0)
1239 return ERR_PTR(-ESTALE);
1240
1241 loc.logicalBlockNum = block;
1242 loc.partitionReferenceNum = partref;
Pekka Enberg97e961f2008-10-15 12:29:03 +02001243 inode = udf_iget(sb, &loc);
Rasmus Rohde221e5832008-04-30 17:22:06 +02001244
1245 if (inode == NULL)
1246 return ERR_PTR(-ENOMEM);
1247
1248 if (generation && inode->i_generation != generation) {
1249 iput(inode);
1250 return ERR_PTR(-ESTALE);
1251 }
Christoph Hellwig44003722008-08-11 15:49:04 +02001252 return d_obtain_alias(inode);
Rasmus Rohde221e5832008-04-30 17:22:06 +02001253}
1254
1255static struct dentry *udf_fh_to_dentry(struct super_block *sb,
1256 struct fid *fid, int fh_len, int fh_type)
1257{
1258 if ((fh_len != 3 && fh_len != 5) ||
1259 (fh_type != FILEID_UDF_WITH_PARENT &&
1260 fh_type != FILEID_UDF_WITHOUT_PARENT))
1261 return NULL;
1262
1263 return udf_nfs_get_inode(sb, fid->udf.block, fid->udf.partref,
1264 fid->udf.generation);
1265}
1266
1267static struct dentry *udf_fh_to_parent(struct super_block *sb,
1268 struct fid *fid, int fh_len, int fh_type)
1269{
1270 if (fh_len != 5 || fh_type != FILEID_UDF_WITH_PARENT)
1271 return NULL;
1272
1273 return udf_nfs_get_inode(sb, fid->udf.parent_block,
1274 fid->udf.parent_partref,
1275 fid->udf.parent_generation);
1276}
1277static int udf_encode_fh(struct dentry *de, __u32 *fh, int *lenp,
1278 int connectable)
1279{
1280 int len = *lenp;
1281 struct inode *inode = de->d_inode;
Pekka Enberg5ca4e4b2008-10-15 12:28:03 +02001282 struct kernel_lb_addr location = UDF_I(inode)->i_location;
Rasmus Rohde221e5832008-04-30 17:22:06 +02001283 struct fid *fid = (struct fid *)fh;
1284 int type = FILEID_UDF_WITHOUT_PARENT;
1285
Aneesh Kumar K.V5fe0c232011-01-29 18:43:25 +05301286 if (connectable && (len < 5)) {
1287 *lenp = 5;
Rasmus Rohde221e5832008-04-30 17:22:06 +02001288 return 255;
Aneesh Kumar K.V5fe0c232011-01-29 18:43:25 +05301289 } else if (len < 3) {
1290 *lenp = 3;
1291 return 255;
1292 }
Rasmus Rohde221e5832008-04-30 17:22:06 +02001293
1294 *lenp = 3;
1295 fid->udf.block = location.logicalBlockNum;
1296 fid->udf.partref = location.partitionReferenceNum;
1297 fid->udf.generation = inode->i_generation;
1298
1299 if (connectable && !S_ISDIR(inode->i_mode)) {
1300 spin_lock(&de->d_lock);
1301 inode = de->d_parent->d_inode;
1302 location = UDF_I(inode)->i_location;
1303 fid->udf.parent_block = location.logicalBlockNum;
1304 fid->udf.parent_partref = location.partitionReferenceNum;
1305 fid->udf.parent_generation = inode->i_generation;
1306 spin_unlock(&de->d_lock);
1307 *lenp = 5;
1308 type = FILEID_UDF_WITH_PARENT;
1309 }
1310
1311 return type;
1312}
1313
1314const struct export_operations udf_export_ops = {
1315 .encode_fh = udf_encode_fh,
1316 .fh_to_dentry = udf_fh_to_dentry,
1317 .fh_to_parent = udf_fh_to_parent,
1318 .get_parent = udf_get_parent,
1319};
1320
Arjan van de Venc5ef1c42007-02-12 00:55:40 -08001321const struct inode_operations udf_dir_inode_operations = {
Cyrill Gorcunov28de7942007-07-21 04:37:18 -07001322 .lookup = udf_lookup,
1323 .create = udf_create,
1324 .link = udf_link,
1325 .unlink = udf_unlink,
1326 .symlink = udf_symlink,
1327 .mkdir = udf_mkdir,
1328 .rmdir = udf_rmdir,
1329 .mknod = udf_mknod,
1330 .rename = udf_rename,
Linus Torvalds1da177e2005-04-16 15:20:36 -07001331};
Dmitry Monakhovc15d0fc2010-03-29 11:05:21 +04001332const struct inode_operations udf_symlink_inode_operations = {
1333 .readlink = generic_readlink,
1334 .follow_link = page_follow_link_light,
1335 .put_link = page_put_link,
Dmitry Monakhovc15d0fc2010-03-29 11:05:21 +04001336};