blob: 08bf46edf9c446b4a6750472eef2c26146f2c053 [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
Al Viro4acdaf22011-07-26 01:42:34 -0400555static int udf_create(struct inode *dir, struct dentry *dentry, umode_t mode,
Cyrill Gorcunovcb00ea32007-07-19 01:47:43 -0700556 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
Al Viro1a67aaf2011-07-26 01:52:52 -0400599static int udf_mknod(struct inode *dir, struct dentry *dentry, umode_t mode,
Cyrill Gorcunovcb00ea32007-07-19 01:47:43 -0700600 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
Al Viro18bb1db2011-07-26 01:41:39 -0400643static int udf_mkdir(struct inode *dir, struct dentry *dentry, umode_t 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)
Joe Perchesa40ecd72011-10-10 01:08:04 -0700799 udf_warn(inode->i_sb, "empty directory has nlink != 2 (%d)\n",
800 inode->i_nlink);
Dave Hansence71ec32006-09-30 23:29:06 -0700801 clear_nlink(inode);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700802 inode->i_size = 0;
Stephen Mollettc007c062007-05-08 00:31:31 -0700803 inode_dec_link_count(dir);
Marcin Slusarz4b111112008-02-08 04:20:36 -0800804 inode->i_ctime = dir->i_ctime = dir->i_mtime =
805 current_fs_time(dir->i_sb);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700806 mark_inode_dirty(dir);
807
Cyrill Gorcunov28de7942007-07-21 04:37:18 -0700808end_rmdir:
Linus Torvalds1da177e2005-04-16 15:20:36 -0700809 if (fibh.sbh != fibh.ebh)
Jan Kara3bf25cb2007-05-08 00:35:16 -0700810 brelse(fibh.ebh);
811 brelse(fibh.sbh);
Cyrill Gorcunov28de7942007-07-21 04:37:18 -0700812
813out:
Linus Torvalds1da177e2005-04-16 15:20:36 -0700814 return retval;
815}
816
Cyrill Gorcunovcb00ea32007-07-19 01:47:43 -0700817static int udf_unlink(struct inode *dir, struct dentry *dentry)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700818{
819 int retval;
Cyrill Gorcunovcb00ea32007-07-19 01:47:43 -0700820 struct inode *inode = dentry->d_inode;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700821 struct udf_fileident_bh fibh;
822 struct fileIdentDesc *fi;
823 struct fileIdentDesc cfi;
Pekka Enberg5ca4e4b2008-10-15 12:28:03 +0200824 struct kernel_lb_addr tloc;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700825
826 retval = -ENOENT;
Al Viro9fbb76c2008-10-12 00:15:17 -0400827 fi = udf_find_entry(dir, &dentry->d_name, &fibh, &cfi);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700828 if (!fi)
829 goto out;
830
831 retval = -EIO;
832 tloc = lelb_to_cpu(cfi.icb.extLocation);
Pekka Enberg97e961f2008-10-15 12:29:03 +0200833 if (udf_get_lb_pblock(dir->i_sb, &tloc, 0) != inode->i_ino)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700834 goto end_unlink;
835
Cyrill Gorcunovcb00ea32007-07-19 01:47:43 -0700836 if (!inode->i_nlink) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700837 udf_debug("Deleting nonexistent file (%lu), %d\n",
Cyrill Gorcunovcb00ea32007-07-19 01:47:43 -0700838 inode->i_ino, inode->i_nlink);
Miklos Szeredibfe86842011-10-28 14:13:29 +0200839 set_nlink(inode, 1);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700840 }
841 retval = udf_delete_entry(dir, fi, &fibh, &cfi);
842 if (retval)
843 goto end_unlink;
844 dir->i_ctime = dir->i_mtime = current_fs_time(dir->i_sb);
845 mark_inode_dirty(dir);
Dave Hansen9a53c3a2006-09-30 23:29:03 -0700846 inode_dec_link_count(inode);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700847 inode->i_ctime = dir->i_ctime;
848 retval = 0;
849
Cyrill Gorcunov28de7942007-07-21 04:37:18 -0700850end_unlink:
Linus Torvalds1da177e2005-04-16 15:20:36 -0700851 if (fibh.sbh != fibh.ebh)
Jan Kara3bf25cb2007-05-08 00:35:16 -0700852 brelse(fibh.ebh);
853 brelse(fibh.sbh);
Cyrill Gorcunov28de7942007-07-21 04:37:18 -0700854
855out:
Linus Torvalds1da177e2005-04-16 15:20:36 -0700856 return retval;
857}
858
Cyrill Gorcunovcb00ea32007-07-19 01:47:43 -0700859static int udf_symlink(struct inode *dir, struct dentry *dentry,
860 const char *symname)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700861{
Cyrill Gorcunovcb00ea32007-07-19 01:47:43 -0700862 struct inode *inode;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700863 struct pathComponent *pc;
Al Viro391e8bb2010-01-31 21:28:48 -0500864 const char *compstart;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700865 struct udf_fileident_bh fibh;
Cyrill Gorcunov28de7942007-07-21 04:37:18 -0700866 struct extent_position epos = {};
Linus Torvalds1da177e2005-04-16 15:20:36 -0700867 int eoffset, elen = 0;
868 struct fileIdentDesc *fi;
869 struct fileIdentDesc cfi;
Al Viro391e8bb2010-01-31 21:28:48 -0500870 uint8_t *ea;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700871 int err;
872 int block;
Al Viro391e8bb2010-01-31 21:28:48 -0500873 unsigned char *name = NULL;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700874 int namelen;
Marcin Slusarz48d6d8f2008-02-08 04:20:44 -0800875 struct udf_inode_info *iinfo;
Jan Karad664b6a2010-10-20 18:28:46 +0200876 struct super_block *sb = dir->i_sb;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700877
Dmitry Monakhova6c5a032010-03-04 17:32:22 +0300878 inode = udf_new_inode(dir, S_IFLNK | S_IRWXUGO, &err);
Marcin Slusarz4b111112008-02-08 04:20:36 -0800879 if (!inode)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700880 goto out;
881
Alessio Igor Bogani4d0fb622010-11-16 18:40:47 +0100882 iinfo = UDF_I(inode);
883 down_write(&iinfo->i_data_sem);
Jan Karab80697c2008-03-04 14:14:05 +0100884 name = kmalloc(UDF_NAME_LEN, GFP_NOFS);
885 if (!name) {
886 err = -ENOMEM;
887 goto out_no_entry;
888 }
889
Linus Torvalds1da177e2005-04-16 15:20:36 -0700890 inode->i_data.a_ops = &udf_symlink_aops;
Dmitry Monakhovc15d0fc2010-03-29 11:05:21 +0400891 inode->i_op = &udf_symlink_inode_operations;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700892
Marcin Slusarz48d6d8f2008-02-08 04:20:44 -0800893 if (iinfo->i_alloc_type != ICBTAG_FLAG_AD_IN_ICB) {
Pekka Enberg5ca4e4b2008-10-15 12:28:03 +0200894 struct kernel_lb_addr eloc;
Harvey Harrison78e917d2008-04-28 02:16:19 -0700895 uint32_t bsize;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700896
Jan Karad664b6a2010-10-20 18:28:46 +0200897 block = udf_new_block(sb, inode,
Marcin Slusarz48d6d8f2008-02-08 04:20:44 -0800898 iinfo->i_location.partitionReferenceNum,
899 iinfo->i_location.logicalBlockNum, &err);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700900 if (!block)
901 goto out_no_entry;
Marcin Slusarz48d6d8f2008-02-08 04:20:44 -0800902 epos.block = iinfo->i_location;
Jan Karaff116fc2007-05-08 00:35:14 -0700903 epos.offset = udf_file_entry_alloc_offset(inode);
904 epos.bh = NULL;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700905 eloc.logicalBlockNum = block;
Marcin Slusarz4b111112008-02-08 04:20:36 -0800906 eloc.partitionReferenceNum =
Marcin Slusarz48d6d8f2008-02-08 04:20:44 -0800907 iinfo->i_location.partitionReferenceNum;
Jan Karad664b6a2010-10-20 18:28:46 +0200908 bsize = sb->s_blocksize;
Harvey Harrison78e917d2008-04-28 02:16:19 -0700909 iinfo->i_lenExtents = bsize;
Pekka Enberg97e961f2008-10-15 12:29:03 +0200910 udf_add_aext(inode, &epos, &eloc, bsize, 0);
Jan Kara3bf25cb2007-05-08 00:35:16 -0700911 brelse(epos.bh);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700912
Jan Karad664b6a2010-10-20 18:28:46 +0200913 block = udf_get_pblock(sb, block,
Marcin Slusarz48d6d8f2008-02-08 04:20:44 -0800914 iinfo->i_location.partitionReferenceNum,
Marcin Slusarz4b111112008-02-08 04:20:36 -0800915 0);
Jan Karad664b6a2010-10-20 18:28:46 +0200916 epos.bh = udf_tgetblk(sb, block);
Jan Karaff116fc2007-05-08 00:35:14 -0700917 lock_buffer(epos.bh);
Jan Karad664b6a2010-10-20 18:28:46 +0200918 memset(epos.bh->b_data, 0x00, bsize);
Jan Karaff116fc2007-05-08 00:35:14 -0700919 set_buffer_uptodate(epos.bh);
920 unlock_buffer(epos.bh);
921 mark_buffer_dirty_inode(epos.bh, inode);
922 ea = epos.bh->b_data + udf_ext0_offset(inode);
Marcin Slusarz48d6d8f2008-02-08 04:20:44 -0800923 } else
924 ea = iinfo->i_ext.i_data + iinfo->i_lenEAttr;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700925
Jan Karad664b6a2010-10-20 18:28:46 +0200926 eoffset = sb->s_blocksize - udf_ext0_offset(inode);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700927 pc = (struct pathComponent *)ea;
928
Cyrill Gorcunovcb00ea32007-07-19 01:47:43 -0700929 if (*symname == '/') {
930 do {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700931 symname++;
932 } while (*symname == '/');
933
934 pc->componentType = 1;
935 pc->lengthComponentIdent = 0;
936 pc->componentFileVersionNum = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700937 elen += sizeof(struct pathComponent);
938 }
939
940 err = -ENAMETOOLONG;
941
Cyrill Gorcunovcb00ea32007-07-19 01:47:43 -0700942 while (*symname) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700943 if (elen + sizeof(struct pathComponent) > eoffset)
944 goto out_no_entry;
945
946 pc = (struct pathComponent *)(ea + elen);
947
Al Viro391e8bb2010-01-31 21:28:48 -0500948 compstart = symname;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700949
Cyrill Gorcunovcb00ea32007-07-19 01:47:43 -0700950 do {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700951 symname++;
952 } while (*symname && *symname != '/');
953
954 pc->componentType = 5;
955 pc->lengthComponentIdent = 0;
956 pc->componentFileVersionNum = 0;
Cyrill Gorcunovcb00ea32007-07-19 01:47:43 -0700957 if (compstart[0] == '.') {
958 if ((symname - compstart) == 1)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700959 pc->componentType = 4;
Marcin Slusarz4b111112008-02-08 04:20:36 -0800960 else if ((symname - compstart) == 2 &&
961 compstart[1] == '.')
Linus Torvalds1da177e2005-04-16 15:20:36 -0700962 pc->componentType = 3;
963 }
964
Cyrill Gorcunovcb00ea32007-07-19 01:47:43 -0700965 if (pc->componentType == 5) {
Jan Karad664b6a2010-10-20 18:28:46 +0200966 namelen = udf_put_filename(sb, compstart, name,
Cyrill Gorcunov28de7942007-07-21 04:37:18 -0700967 symname - compstart);
968 if (!namelen)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700969 goto out_no_entry;
970
Marcin Slusarz4b111112008-02-08 04:20:36 -0800971 if (elen + sizeof(struct pathComponent) + namelen >
972 eoffset)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700973 goto out_no_entry;
974 else
975 pc->lengthComponentIdent = namelen;
976
977 memcpy(pc->componentIdent, name, namelen);
978 }
979
980 elen += sizeof(struct pathComponent) + pc->lengthComponentIdent;
981
Cyrill Gorcunovcb00ea32007-07-19 01:47:43 -0700982 if (*symname) {
983 do {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700984 symname++;
985 } while (*symname == '/');
986 }
987 }
988
Jan Kara3bf25cb2007-05-08 00:35:16 -0700989 brelse(epos.bh);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700990 inode->i_size = elen;
Marcin Slusarz48d6d8f2008-02-08 04:20:44 -0800991 if (iinfo->i_alloc_type == ICBTAG_FLAG_AD_IN_ICB)
992 iinfo->i_lenAlloc = inode->i_size;
Jan Kara2c948b32009-12-03 13:39:28 +0100993 else
994 udf_truncate_tail_extent(inode);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700995 mark_inode_dirty(inode);
996
Marcin Slusarz4b111112008-02-08 04:20:36 -0800997 fi = udf_add_entry(dir, dentry, &fibh, &cfi, &err);
998 if (!fi)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700999 goto out_no_entry;
Jan Karad664b6a2010-10-20 18:28:46 +02001000 cfi.icb.extLength = cpu_to_le32(sb->s_blocksize);
Marcin Slusarz48d6d8f2008-02-08 04:20:44 -08001001 cfi.icb.extLocation = cpu_to_lelb(iinfo->i_location);
Jan Karad664b6a2010-10-20 18:28:46 +02001002 if (UDF_SB(inode->i_sb)->s_lvid_bh) {
Cyrill Gorcunov28de7942007-07-21 04:37:18 -07001003 *(__le32 *)((struct allocDescImpUse *)cfi.icb.impUse)->impUse =
Jan Karad664b6a2010-10-20 18:28:46 +02001004 cpu_to_le32(lvid_get_unique_id(sb));
Linus Torvalds1da177e2005-04-16 15:20:36 -07001005 }
1006 udf_write_fi(dir, &cfi, fi, &fibh, NULL, NULL);
Marcin Slusarzc0b34432008-02-08 04:20:42 -08001007 if (UDF_I(dir)->i_alloc_type == ICBTAG_FLAG_AD_IN_ICB)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001008 mark_inode_dirty(dir);
Alessio Igor Bogani4d0fb622010-11-16 18:40:47 +01001009 up_write(&iinfo->i_data_sem);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001010 if (fibh.sbh != fibh.ebh)
Jan Kara3bf25cb2007-05-08 00:35:16 -07001011 brelse(fibh.ebh);
1012 brelse(fibh.sbh);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001013 d_instantiate(dentry, inode);
1014 err = 0;
1015
Cyrill Gorcunov28de7942007-07-21 04:37:18 -07001016out:
Jan Karab80697c2008-03-04 14:14:05 +01001017 kfree(name);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001018 return err;
1019
Cyrill Gorcunov28de7942007-07-21 04:37:18 -07001020out_no_entry:
Alessio Igor Bogani4d0fb622010-11-16 18:40:47 +01001021 up_write(&iinfo->i_data_sem);
Dave Hansen9a53c3a2006-09-30 23:29:03 -07001022 inode_dec_link_count(inode);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001023 iput(inode);
1024 goto out;
1025}
1026
Cyrill Gorcunovcb00ea32007-07-19 01:47:43 -07001027static int udf_link(struct dentry *old_dentry, struct inode *dir,
1028 struct dentry *dentry)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001029{
1030 struct inode *inode = old_dentry->d_inode;
1031 struct udf_fileident_bh fibh;
1032 struct fileIdentDesc cfi, *fi;
1033 int err;
1034
Al Viro810c1b2e2011-03-02 10:15:26 -05001035 if (inode->i_nlink >= UDF_MAX_LINKS)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001036 return -EMLINK;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001037
Marcin Slusarz4b111112008-02-08 04:20:36 -08001038 fi = udf_add_entry(dir, dentry, &fibh, &cfi, &err);
1039 if (!fi) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001040 return err;
1041 }
1042 cfi.icb.extLength = cpu_to_le32(inode->i_sb->s_blocksize);
Marcin Slusarzc0b34432008-02-08 04:20:42 -08001043 cfi.icb.extLocation = cpu_to_lelb(UDF_I(inode)->i_location);
Jan Karad664b6a2010-10-20 18:28:46 +02001044 if (UDF_SB(inode->i_sb)->s_lvid_bh) {
Cyrill Gorcunov28de7942007-07-21 04:37:18 -07001045 *(__le32 *)((struct allocDescImpUse *)cfi.icb.impUse)->impUse =
Jan Karad664b6a2010-10-20 18:28:46 +02001046 cpu_to_le32(lvid_get_unique_id(inode->i_sb));
Linus Torvalds1da177e2005-04-16 15:20:36 -07001047 }
1048 udf_write_fi(dir, &cfi, fi, &fibh, NULL, NULL);
Marcin Slusarzc0b34432008-02-08 04:20:42 -08001049 if (UDF_I(dir)->i_alloc_type == ICBTAG_FLAG_AD_IN_ICB)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001050 mark_inode_dirty(dir);
Cyrill Gorcunov28de7942007-07-21 04:37:18 -07001051
Linus Torvalds1da177e2005-04-16 15:20:36 -07001052 if (fibh.sbh != fibh.ebh)
Jan Kara3bf25cb2007-05-08 00:35:16 -07001053 brelse(fibh.ebh);
1054 brelse(fibh.sbh);
Dave Hansend8c76e62006-09-30 23:29:04 -07001055 inc_nlink(inode);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001056 inode->i_ctime = current_fs_time(inode->i_sb);
1057 mark_inode_dirty(inode);
Al Viro7de9c6ee2010-10-23 11:11:40 -04001058 ihold(inode);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001059 d_instantiate(dentry, inode);
Cyrill Gorcunov28de7942007-07-21 04:37:18 -07001060
Linus Torvalds1da177e2005-04-16 15:20:36 -07001061 return 0;
1062}
1063
1064/* Anybody can rename anything with this: the permission checks are left to the
1065 * higher-level routines.
1066 */
Cyrill Gorcunovcb00ea32007-07-19 01:47:43 -07001067static int udf_rename(struct inode *old_dir, struct dentry *old_dentry,
1068 struct inode *new_dir, struct dentry *new_dentry)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001069{
Cyrill Gorcunovcb00ea32007-07-19 01:47:43 -07001070 struct inode *old_inode = old_dentry->d_inode;
1071 struct inode *new_inode = new_dentry->d_inode;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001072 struct udf_fileident_bh ofibh, nfibh;
Marcin Slusarz4b111112008-02-08 04:20:36 -08001073 struct fileIdentDesc *ofi = NULL, *nfi = NULL, *dir_fi = NULL;
1074 struct fileIdentDesc ocfi, ncfi;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001075 struct buffer_head *dir_bh = NULL;
1076 int retval = -ENOENT;
Pekka Enberg5ca4e4b2008-10-15 12:28:03 +02001077 struct kernel_lb_addr tloc;
Marcin Slusarz48d6d8f2008-02-08 04:20:44 -08001078 struct udf_inode_info *old_iinfo = UDF_I(old_inode);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001079
Al Viro9fbb76c2008-10-12 00:15:17 -04001080 ofi = udf_find_entry(old_dir, &old_dentry->d_name, &ofibh, &ocfi);
Marcin Slusarz4b111112008-02-08 04:20:36 -08001081 if (ofi) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001082 if (ofibh.sbh != ofibh.ebh)
Jan Kara3bf25cb2007-05-08 00:35:16 -07001083 brelse(ofibh.ebh);
1084 brelse(ofibh.sbh);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001085 }
1086 tloc = lelb_to_cpu(ocfi.icb.extLocation);
Pekka Enberg97e961f2008-10-15 12:29:03 +02001087 if (!ofi || udf_get_lb_pblock(old_dir->i_sb, &tloc, 0)
Cyrill Gorcunovcb00ea32007-07-19 01:47:43 -07001088 != old_inode->i_ino)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001089 goto end_rename;
1090
Al Viro9fbb76c2008-10-12 00:15:17 -04001091 nfi = udf_find_entry(new_dir, &new_dentry->d_name, &nfibh, &ncfi);
Cyrill Gorcunovcb00ea32007-07-19 01:47:43 -07001092 if (nfi) {
1093 if (!new_inode) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001094 if (nfibh.sbh != nfibh.ebh)
Jan Kara3bf25cb2007-05-08 00:35:16 -07001095 brelse(nfibh.ebh);
1096 brelse(nfibh.sbh);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001097 nfi = NULL;
1098 }
1099 }
Cyrill Gorcunovcb00ea32007-07-19 01:47:43 -07001100 if (S_ISDIR(old_inode->i_mode)) {
Marcin Slusarz7f3fbd02008-02-08 04:20:49 -08001101 int offset = udf_ext0_offset(old_inode);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001102
Cyrill Gorcunovcb00ea32007-07-19 01:47:43 -07001103 if (new_inode) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001104 retval = -ENOTEMPTY;
1105 if (!empty_dir(new_inode))
1106 goto end_rename;
1107 }
1108 retval = -EIO;
Marcin Slusarz48d6d8f2008-02-08 04:20:44 -08001109 if (old_iinfo->i_alloc_type == ICBTAG_FLAG_AD_IN_ICB) {
Marcin Slusarz4b111112008-02-08 04:20:36 -08001110 dir_fi = udf_get_fileident(
Marcin Slusarz48d6d8f2008-02-08 04:20:44 -08001111 old_iinfo->i_ext.i_data -
1112 (old_iinfo->i_efe ?
Marcin Slusarz4b111112008-02-08 04:20:36 -08001113 sizeof(struct extendedFileEntry) :
1114 sizeof(struct fileEntry)),
1115 old_inode->i_sb->s_blocksize, &offset);
Cyrill Gorcunovcb00ea32007-07-19 01:47:43 -07001116 } else {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001117 dir_bh = udf_bread(old_inode, 0, 0, &retval);
1118 if (!dir_bh)
1119 goto end_rename;
Marcin Slusarz4b111112008-02-08 04:20:36 -08001120 dir_fi = udf_get_fileident(dir_bh->b_data,
1121 old_inode->i_sb->s_blocksize, &offset);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001122 }
1123 if (!dir_fi)
1124 goto end_rename;
1125 tloc = lelb_to_cpu(dir_fi->icb.extLocation);
Pekka Enberg97e961f2008-10-15 12:29:03 +02001126 if (udf_get_lb_pblock(old_inode->i_sb, &tloc, 0) !=
Marcin Slusarz4b111112008-02-08 04:20:36 -08001127 old_dir->i_ino)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001128 goto end_rename;
1129
1130 retval = -EMLINK;
Al Viro810c1b2e2011-03-02 10:15:26 -05001131 if (!new_inode && new_dir->i_nlink >= UDF_MAX_LINKS)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001132 goto end_rename;
1133 }
Cyrill Gorcunovcb00ea32007-07-19 01:47:43 -07001134 if (!nfi) {
Marcin Slusarz4b111112008-02-08 04:20:36 -08001135 nfi = udf_add_entry(new_dir, new_dentry, &nfibh, &ncfi,
1136 &retval);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001137 if (!nfi)
1138 goto end_rename;
1139 }
1140
1141 /*
1142 * Like most other Unix systems, set the ctime for inodes on a
1143 * rename.
1144 */
1145 old_inode->i_ctime = current_fs_time(old_inode->i_sb);
1146 mark_inode_dirty(old_inode);
1147
1148 /*
1149 * ok, that's it
1150 */
1151 ncfi.fileVersionNum = ocfi.fileVersionNum;
1152 ncfi.fileCharacteristics = ocfi.fileCharacteristics;
Pekka Enberg5ca4e4b2008-10-15 12:28:03 +02001153 memcpy(&(ncfi.icb), &(ocfi.icb), sizeof(struct long_ad));
Linus Torvalds1da177e2005-04-16 15:20:36 -07001154 udf_write_fi(new_dir, &ncfi, nfi, &nfibh, NULL, NULL);
1155
1156 /* The old fid may have moved - find it again */
Al Viro9fbb76c2008-10-12 00:15:17 -04001157 ofi = udf_find_entry(old_dir, &old_dentry->d_name, &ofibh, &ocfi);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001158 udf_delete_entry(old_dir, ofi, &ofibh, &ocfi);
1159
Cyrill Gorcunovcb00ea32007-07-19 01:47:43 -07001160 if (new_inode) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001161 new_inode->i_ctime = current_fs_time(new_inode->i_sb);
Dave Hansen9a53c3a2006-09-30 23:29:03 -07001162 inode_dec_link_count(new_inode);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001163 }
1164 old_dir->i_ctime = old_dir->i_mtime = current_fs_time(old_dir->i_sb);
1165 mark_inode_dirty(old_dir);
1166
Cyrill Gorcunovcb00ea32007-07-19 01:47:43 -07001167 if (dir_fi) {
Marcin Slusarzc0b34432008-02-08 04:20:42 -08001168 dir_fi->icb.extLocation = cpu_to_lelb(UDF_I(new_dir)->i_location);
Marcin Slusarz4b111112008-02-08 04:20:36 -08001169 udf_update_tag((char *)dir_fi,
1170 (sizeof(struct fileIdentDesc) +
1171 le16_to_cpu(dir_fi->lengthOfImpUse) + 3) & ~3);
Marcin Slusarz48d6d8f2008-02-08 04:20:44 -08001172 if (old_iinfo->i_alloc_type == ICBTAG_FLAG_AD_IN_ICB)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001173 mark_inode_dirty(old_inode);
Marcin Slusarz4b111112008-02-08 04:20:36 -08001174 else
Linus Torvalds1da177e2005-04-16 15:20:36 -07001175 mark_buffer_dirty_inode(dir_bh, old_inode);
Marcin Slusarz4b111112008-02-08 04:20:36 -08001176
Dave Hansen9a53c3a2006-09-30 23:29:03 -07001177 inode_dec_link_count(old_dir);
Marcin Slusarz4b111112008-02-08 04:20:36 -08001178 if (new_inode)
Dave Hansen9a53c3a2006-09-30 23:29:03 -07001179 inode_dec_link_count(new_inode);
Marcin Slusarz4b111112008-02-08 04:20:36 -08001180 else {
Dave Hansend8c76e62006-09-30 23:29:04 -07001181 inc_nlink(new_dir);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001182 mark_inode_dirty(new_dir);
1183 }
1184 }
1185
Cyrill Gorcunovcb00ea32007-07-19 01:47:43 -07001186 if (ofi) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001187 if (ofibh.sbh != ofibh.ebh)
Jan Kara3bf25cb2007-05-08 00:35:16 -07001188 brelse(ofibh.ebh);
1189 brelse(ofibh.sbh);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001190 }
1191
1192 retval = 0;
1193
Cyrill Gorcunov28de7942007-07-21 04:37:18 -07001194end_rename:
Jan Kara3bf25cb2007-05-08 00:35:16 -07001195 brelse(dir_bh);
Cyrill Gorcunovcb00ea32007-07-19 01:47:43 -07001196 if (nfi) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001197 if (nfibh.sbh != nfibh.ebh)
Jan Kara3bf25cb2007-05-08 00:35:16 -07001198 brelse(nfibh.ebh);
1199 brelse(nfibh.sbh);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001200 }
Cyrill Gorcunov28de7942007-07-21 04:37:18 -07001201
Linus Torvalds1da177e2005-04-16 15:20:36 -07001202 return retval;
1203}
1204
Rasmus Rohde221e5832008-04-30 17:22:06 +02001205static struct dentry *udf_get_parent(struct dentry *child)
1206{
Pekka Enberg97e961f2008-10-15 12:29:03 +02001207 struct kernel_lb_addr tloc;
Rasmus Rohde221e5832008-04-30 17:22:06 +02001208 struct inode *inode = NULL;
Al Viro9fbb76c2008-10-12 00:15:17 -04001209 struct qstr dotdot = {.name = "..", .len = 2};
Rasmus Rohde221e5832008-04-30 17:22:06 +02001210 struct fileIdentDesc cfi;
1211 struct udf_fileident_bh fibh;
1212
Rasmus Rohde221e5832008-04-30 17:22:06 +02001213 if (!udf_find_entry(child->d_inode, &dotdot, &fibh, &cfi))
1214 goto out_unlock;
1215
1216 if (fibh.sbh != fibh.ebh)
1217 brelse(fibh.ebh);
1218 brelse(fibh.sbh);
1219
Pekka Enberg97e961f2008-10-15 12:29:03 +02001220 tloc = lelb_to_cpu(cfi.icb.extLocation);
1221 inode = udf_iget(child->d_inode->i_sb, &tloc);
Rasmus Rohde221e5832008-04-30 17:22:06 +02001222 if (!inode)
1223 goto out_unlock;
Rasmus Rohde221e5832008-04-30 17:22:06 +02001224
Christoph Hellwig44003722008-08-11 15:49:04 +02001225 return d_obtain_alias(inode);
Rasmus Rohde221e5832008-04-30 17:22:06 +02001226out_unlock:
Rasmus Rohde221e5832008-04-30 17:22:06 +02001227 return ERR_PTR(-EACCES);
1228}
1229
1230
1231static struct dentry *udf_nfs_get_inode(struct super_block *sb, u32 block,
1232 u16 partref, __u32 generation)
1233{
1234 struct inode *inode;
Pekka Enberg5ca4e4b2008-10-15 12:28:03 +02001235 struct kernel_lb_addr loc;
Rasmus Rohde221e5832008-04-30 17:22:06 +02001236
1237 if (block == 0)
1238 return ERR_PTR(-ESTALE);
1239
1240 loc.logicalBlockNum = block;
1241 loc.partitionReferenceNum = partref;
Pekka Enberg97e961f2008-10-15 12:29:03 +02001242 inode = udf_iget(sb, &loc);
Rasmus Rohde221e5832008-04-30 17:22:06 +02001243
1244 if (inode == NULL)
1245 return ERR_PTR(-ENOMEM);
1246
1247 if (generation && inode->i_generation != generation) {
1248 iput(inode);
1249 return ERR_PTR(-ESTALE);
1250 }
Christoph Hellwig44003722008-08-11 15:49:04 +02001251 return d_obtain_alias(inode);
Rasmus Rohde221e5832008-04-30 17:22:06 +02001252}
1253
1254static struct dentry *udf_fh_to_dentry(struct super_block *sb,
1255 struct fid *fid, int fh_len, int fh_type)
1256{
1257 if ((fh_len != 3 && fh_len != 5) ||
1258 (fh_type != FILEID_UDF_WITH_PARENT &&
1259 fh_type != FILEID_UDF_WITHOUT_PARENT))
1260 return NULL;
1261
1262 return udf_nfs_get_inode(sb, fid->udf.block, fid->udf.partref,
1263 fid->udf.generation);
1264}
1265
1266static struct dentry *udf_fh_to_parent(struct super_block *sb,
1267 struct fid *fid, int fh_len, int fh_type)
1268{
1269 if (fh_len != 5 || fh_type != FILEID_UDF_WITH_PARENT)
1270 return NULL;
1271
1272 return udf_nfs_get_inode(sb, fid->udf.parent_block,
1273 fid->udf.parent_partref,
1274 fid->udf.parent_generation);
1275}
1276static int udf_encode_fh(struct dentry *de, __u32 *fh, int *lenp,
1277 int connectable)
1278{
1279 int len = *lenp;
1280 struct inode *inode = de->d_inode;
Pekka Enberg5ca4e4b2008-10-15 12:28:03 +02001281 struct kernel_lb_addr location = UDF_I(inode)->i_location;
Rasmus Rohde221e5832008-04-30 17:22:06 +02001282 struct fid *fid = (struct fid *)fh;
1283 int type = FILEID_UDF_WITHOUT_PARENT;
1284
Aneesh Kumar K.V5fe0c232011-01-29 18:43:25 +05301285 if (connectable && (len < 5)) {
1286 *lenp = 5;
Rasmus Rohde221e5832008-04-30 17:22:06 +02001287 return 255;
Aneesh Kumar K.V5fe0c232011-01-29 18:43:25 +05301288 } else if (len < 3) {
1289 *lenp = 3;
1290 return 255;
1291 }
Rasmus Rohde221e5832008-04-30 17:22:06 +02001292
1293 *lenp = 3;
1294 fid->udf.block = location.logicalBlockNum;
1295 fid->udf.partref = location.partitionReferenceNum;
1296 fid->udf.generation = inode->i_generation;
1297
1298 if (connectable && !S_ISDIR(inode->i_mode)) {
1299 spin_lock(&de->d_lock);
1300 inode = de->d_parent->d_inode;
1301 location = UDF_I(inode)->i_location;
1302 fid->udf.parent_block = location.logicalBlockNum;
1303 fid->udf.parent_partref = location.partitionReferenceNum;
1304 fid->udf.parent_generation = inode->i_generation;
1305 spin_unlock(&de->d_lock);
1306 *lenp = 5;
1307 type = FILEID_UDF_WITH_PARENT;
1308 }
1309
1310 return type;
1311}
1312
1313const struct export_operations udf_export_ops = {
1314 .encode_fh = udf_encode_fh,
1315 .fh_to_dentry = udf_fh_to_dentry,
1316 .fh_to_parent = udf_fh_to_parent,
1317 .get_parent = udf_get_parent,
1318};
1319
Arjan van de Venc5ef1c42007-02-12 00:55:40 -08001320const struct inode_operations udf_dir_inode_operations = {
Cyrill Gorcunov28de7942007-07-21 04:37:18 -07001321 .lookup = udf_lookup,
1322 .create = udf_create,
1323 .link = udf_link,
1324 .unlink = udf_unlink,
1325 .symlink = udf_symlink,
1326 .mkdir = udf_mkdir,
1327 .rmdir = udf_rmdir,
1328 .mknod = udf_mknod,
1329 .rename = udf_rename,
Linus Torvalds1da177e2005-04-16 15:20:36 -07001330};
Dmitry Monakhovc15d0fc2010-03-29 11:05:21 +04001331const struct inode_operations udf_symlink_inode_operations = {
1332 .readlink = generic_readlink,
1333 .follow_link = page_follow_link_light,
1334 .put_link = page_put_link,
Dmitry Monakhovc15d0fc2010-03-29 11:05:21 +04001335};