blob: f1dce848ef966ea1853c9f50ce2d9cc997114a18 [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) {
Cyrill Gorcunovcb00ea32007-07-19 01:47:43 -0700580 inode->i_nlink--;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700581 mark_inode_dirty(inode);
582 iput(inode);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700583 return err;
584 }
585 cfi.icb.extLength = cpu_to_le32(inode->i_sb->s_blocksize);
Marcin Slusarz48d6d8f2008-02-08 04:20:44 -0800586 cfi.icb.extLocation = cpu_to_lelb(iinfo->i_location);
Cyrill Gorcunov28de7942007-07-21 04:37:18 -0700587 *(__le32 *)((struct allocDescImpUse *)cfi.icb.impUse)->impUse =
Marcin Slusarz48d6d8f2008-02-08 04:20:44 -0800588 cpu_to_le32(iinfo->i_unique & 0x00000000FFFFFFFFUL);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700589 udf_write_fi(dir, &cfi, fi, &fibh, NULL, NULL);
Marcin Slusarzc0b34432008-02-08 04:20:42 -0800590 if (UDF_I(dir)->i_alloc_type == ICBTAG_FLAG_AD_IN_ICB)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700591 mark_inode_dirty(dir);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700592 if (fibh.sbh != fibh.ebh)
Jan Kara3bf25cb2007-05-08 00:35:16 -0700593 brelse(fibh.ebh);
594 brelse(fibh.sbh);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700595 d_instantiate(dentry, inode);
Cyrill Gorcunov28de7942007-07-21 04:37:18 -0700596
Linus Torvalds1da177e2005-04-16 15:20:36 -0700597 return 0;
598}
599
Cyrill Gorcunovcb00ea32007-07-19 01:47:43 -0700600static int udf_mknod(struct inode *dir, struct dentry *dentry, int mode,
601 dev_t rdev)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700602{
Cyrill Gorcunovcb00ea32007-07-19 01:47:43 -0700603 struct inode *inode;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700604 struct udf_fileident_bh fibh;
605 struct fileIdentDesc cfi, *fi;
606 int err;
Marcin Slusarz48d6d8f2008-02-08 04:20:44 -0800607 struct udf_inode_info *iinfo;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700608
609 if (!old_valid_dev(rdev))
610 return -EINVAL;
611
Linus Torvalds1da177e2005-04-16 15:20:36 -0700612 err = -EIO;
613 inode = udf_new_inode(dir, mode, &err);
614 if (!inode)
615 goto out;
616
Marcin Slusarz48d6d8f2008-02-08 04:20:44 -0800617 iinfo = UDF_I(inode);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700618 init_special_inode(inode, mode, rdev);
Marcin Slusarz4b111112008-02-08 04:20:36 -0800619 fi = udf_add_entry(dir, dentry, &fibh, &cfi, &err);
620 if (!fi) {
Cyrill Gorcunovcb00ea32007-07-19 01:47:43 -0700621 inode->i_nlink--;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700622 mark_inode_dirty(inode);
623 iput(inode);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700624 return err;
625 }
626 cfi.icb.extLength = cpu_to_le32(inode->i_sb->s_blocksize);
Marcin Slusarz48d6d8f2008-02-08 04:20:44 -0800627 cfi.icb.extLocation = cpu_to_lelb(iinfo->i_location);
Cyrill Gorcunov28de7942007-07-21 04:37:18 -0700628 *(__le32 *)((struct allocDescImpUse *)cfi.icb.impUse)->impUse =
Marcin Slusarz48d6d8f2008-02-08 04:20:44 -0800629 cpu_to_le32(iinfo->i_unique & 0x00000000FFFFFFFFUL);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700630 udf_write_fi(dir, &cfi, fi, &fibh, NULL, NULL);
Marcin Slusarzc0b34432008-02-08 04:20:42 -0800631 if (UDF_I(dir)->i_alloc_type == ICBTAG_FLAG_AD_IN_ICB)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700632 mark_inode_dirty(dir);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700633 mark_inode_dirty(inode);
634
635 if (fibh.sbh != fibh.ebh)
Jan Kara3bf25cb2007-05-08 00:35:16 -0700636 brelse(fibh.ebh);
637 brelse(fibh.sbh);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700638 d_instantiate(dentry, inode);
639 err = 0;
Cyrill Gorcunov28de7942007-07-21 04:37:18 -0700640
641out:
Linus Torvalds1da177e2005-04-16 15:20:36 -0700642 return err;
643}
644
Cyrill Gorcunovcb00ea32007-07-19 01:47:43 -0700645static int udf_mkdir(struct inode *dir, struct dentry *dentry, int mode)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700646{
Cyrill Gorcunovcb00ea32007-07-19 01:47:43 -0700647 struct inode *inode;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700648 struct udf_fileident_bh fibh;
649 struct fileIdentDesc cfi, *fi;
650 int err;
Marcin Slusarz48d6d8f2008-02-08 04:20:44 -0800651 struct udf_inode_info *dinfo = UDF_I(dir);
652 struct udf_inode_info *iinfo;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700653
Linus Torvalds1da177e2005-04-16 15:20:36 -0700654 err = -EMLINK;
Al Viro810c1b2e2011-03-02 10:15:26 -0500655 if (dir->i_nlink >= UDF_MAX_LINKS)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700656 goto out;
657
658 err = -EIO;
Dmitry Monakhova6c5a032010-03-04 17:32:22 +0300659 inode = udf_new_inode(dir, S_IFDIR | mode, &err);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700660 if (!inode)
661 goto out;
662
Marcin Slusarz48d6d8f2008-02-08 04:20:44 -0800663 iinfo = UDF_I(inode);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700664 inode->i_op = &udf_dir_inode_operations;
665 inode->i_fop = &udf_dir_operations;
Marcin Slusarz4b111112008-02-08 04:20:36 -0800666 fi = udf_add_entry(inode, NULL, &fibh, &cfi, &err);
667 if (!fi) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700668 inode->i_nlink--;
669 mark_inode_dirty(inode);
670 iput(inode);
671 goto out;
672 }
673 inode->i_nlink = 2;
674 cfi.icb.extLength = cpu_to_le32(inode->i_sb->s_blocksize);
Marcin Slusarz48d6d8f2008-02-08 04:20:44 -0800675 cfi.icb.extLocation = cpu_to_lelb(dinfo->i_location);
Cyrill Gorcunov28de7942007-07-21 04:37:18 -0700676 *(__le32 *)((struct allocDescImpUse *)cfi.icb.impUse)->impUse =
Marcin Slusarz48d6d8f2008-02-08 04:20:44 -0800677 cpu_to_le32(dinfo->i_unique & 0x00000000FFFFFFFFUL);
Marcin Slusarz4b111112008-02-08 04:20:36 -0800678 cfi.fileCharacteristics =
679 FID_FILE_CHAR_DIRECTORY | FID_FILE_CHAR_PARENT;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700680 udf_write_fi(inode, &cfi, fi, &fibh, NULL, NULL);
Jan Kara3bf25cb2007-05-08 00:35:16 -0700681 brelse(fibh.sbh);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700682 mark_inode_dirty(inode);
683
Marcin Slusarz4b111112008-02-08 04:20:36 -0800684 fi = udf_add_entry(dir, dentry, &fibh, &cfi, &err);
685 if (!fi) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700686 inode->i_nlink = 0;
687 mark_inode_dirty(inode);
688 iput(inode);
689 goto out;
690 }
691 cfi.icb.extLength = cpu_to_le32(inode->i_sb->s_blocksize);
Marcin Slusarz48d6d8f2008-02-08 04:20:44 -0800692 cfi.icb.extLocation = cpu_to_lelb(iinfo->i_location);
Cyrill Gorcunov28de7942007-07-21 04:37:18 -0700693 *(__le32 *)((struct allocDescImpUse *)cfi.icb.impUse)->impUse =
Marcin Slusarz48d6d8f2008-02-08 04:20:44 -0800694 cpu_to_le32(iinfo->i_unique & 0x00000000FFFFFFFFUL);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700695 cfi.fileCharacteristics |= FID_FILE_CHAR_DIRECTORY;
696 udf_write_fi(dir, &cfi, fi, &fibh, NULL, NULL);
Dave Hansend8c76e62006-09-30 23:29:04 -0700697 inc_nlink(dir);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700698 mark_inode_dirty(dir);
699 d_instantiate(dentry, inode);
700 if (fibh.sbh != fibh.ebh)
Jan Kara3bf25cb2007-05-08 00:35:16 -0700701 brelse(fibh.ebh);
702 brelse(fibh.sbh);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700703 err = 0;
Cyrill Gorcunov28de7942007-07-21 04:37:18 -0700704
705out:
Linus Torvalds1da177e2005-04-16 15:20:36 -0700706 return err;
707}
708
709static int empty_dir(struct inode *dir)
710{
711 struct fileIdentDesc *fi, cfi;
712 struct udf_fileident_bh fibh;
713 loff_t f_pos;
Jan Karaaf793292008-02-08 04:20:50 -0800714 loff_t size = udf_ext0_offset(dir) + dir->i_size;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700715 int block;
Pekka Enberg5ca4e4b2008-10-15 12:28:03 +0200716 struct kernel_lb_addr eloc;
Jan Karaff116fc2007-05-08 00:35:14 -0700717 uint32_t elen;
Jan Kara60448b12007-05-08 00:35:13 -0700718 sector_t offset;
Cyrill Gorcunov28de7942007-07-21 04:37:18 -0700719 struct extent_position epos = {};
Marcin Slusarz48d6d8f2008-02-08 04:20:44 -0800720 struct udf_inode_info *dinfo = UDF_I(dir);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700721
Jan Karaaf793292008-02-08 04:20:50 -0800722 f_pos = udf_ext0_offset(dir);
723 fibh.soffset = fibh.eoffset = f_pos & (dir->i_sb->s_blocksize - 1);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700724
Marcin Slusarz48d6d8f2008-02-08 04:20:44 -0800725 if (dinfo->i_alloc_type == ICBTAG_FLAG_AD_IN_ICB)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700726 fibh.sbh = fibh.ebh = NULL;
Jan Karaaf793292008-02-08 04:20:50 -0800727 else if (inode_bmap(dir, f_pos >> dir->i_sb->s_blocksize_bits,
Marcin Slusarz4b111112008-02-08 04:20:36 -0800728 &epos, &eloc, &elen, &offset) ==
729 (EXT_RECORDED_ALLOCATED >> 30)) {
Pekka Enberg97e961f2008-10-15 12:29:03 +0200730 block = udf_get_lb_pblock(dir->i_sb, &eloc, offset);
Cyrill Gorcunovcb00ea32007-07-19 01:47:43 -0700731 if ((++offset << dir->i_sb->s_blocksize_bits) < elen) {
Marcin Slusarz48d6d8f2008-02-08 04:20:44 -0800732 if (dinfo->i_alloc_type == ICBTAG_FLAG_AD_SHORT)
Pekka Enberg5ca4e4b2008-10-15 12:28:03 +0200733 epos.offset -= sizeof(struct short_ad);
Marcin Slusarz48d6d8f2008-02-08 04:20:44 -0800734 else if (dinfo->i_alloc_type == ICBTAG_FLAG_AD_LONG)
Pekka Enberg5ca4e4b2008-10-15 12:28:03 +0200735 epos.offset -= sizeof(struct long_ad);
Marcin Slusarz4b111112008-02-08 04:20:36 -0800736 } else
Linus Torvalds1da177e2005-04-16 15:20:36 -0700737 offset = 0;
738
Marcin Slusarz4b111112008-02-08 04:20:36 -0800739 fibh.sbh = fibh.ebh = udf_tread(dir->i_sb, block);
740 if (!fibh.sbh) {
Jan Kara3bf25cb2007-05-08 00:35:16 -0700741 brelse(epos.bh);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700742 return 0;
743 }
Cyrill Gorcunovcb00ea32007-07-19 01:47:43 -0700744 } else {
Jan Kara3bf25cb2007-05-08 00:35:16 -0700745 brelse(epos.bh);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700746 return 0;
747 }
748
Jan Karaaf793292008-02-08 04:20:50 -0800749 while (f_pos < size) {
Cyrill Gorcunovcb00ea32007-07-19 01:47:43 -0700750 fi = udf_fileident_read(dir, &f_pos, &fibh, &cfi, &epos, &eloc,
751 &elen, &offset);
Cyrill Gorcunovcb00ea32007-07-19 01:47:43 -0700752 if (!fi) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700753 if (fibh.sbh != fibh.ebh)
Jan Kara3bf25cb2007-05-08 00:35:16 -0700754 brelse(fibh.ebh);
755 brelse(fibh.sbh);
756 brelse(epos.bh);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700757 return 0;
758 }
759
Cyrill Gorcunov28de7942007-07-21 04:37:18 -0700760 if (cfi.lengthFileIdent &&
761 (cfi.fileCharacteristics & FID_FILE_CHAR_DELETED) == 0) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700762 if (fibh.sbh != fibh.ebh)
Jan Kara3bf25cb2007-05-08 00:35:16 -0700763 brelse(fibh.ebh);
764 brelse(fibh.sbh);
765 brelse(epos.bh);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700766 return 0;
767 }
768 }
Cyrill Gorcunov28de7942007-07-21 04:37:18 -0700769
Linus Torvalds1da177e2005-04-16 15:20:36 -0700770 if (fibh.sbh != fibh.ebh)
Jan Kara3bf25cb2007-05-08 00:35:16 -0700771 brelse(fibh.ebh);
772 brelse(fibh.sbh);
773 brelse(epos.bh);
Cyrill Gorcunov28de7942007-07-21 04:37:18 -0700774
Linus Torvalds1da177e2005-04-16 15:20:36 -0700775 return 1;
776}
777
Cyrill Gorcunovcb00ea32007-07-19 01:47:43 -0700778static int udf_rmdir(struct inode *dir, struct dentry *dentry)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700779{
780 int retval;
Cyrill Gorcunovcb00ea32007-07-19 01:47:43 -0700781 struct inode *inode = dentry->d_inode;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700782 struct udf_fileident_bh fibh;
783 struct fileIdentDesc *fi, cfi;
Pekka Enberg5ca4e4b2008-10-15 12:28:03 +0200784 struct kernel_lb_addr tloc;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700785
786 retval = -ENOENT;
Al Viro9fbb76c2008-10-12 00:15:17 -0400787 fi = udf_find_entry(dir, &dentry->d_name, &fibh, &cfi);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700788 if (!fi)
789 goto out;
790
791 retval = -EIO;
792 tloc = lelb_to_cpu(cfi.icb.extLocation);
Pekka Enberg97e961f2008-10-15 12:29:03 +0200793 if (udf_get_lb_pblock(dir->i_sb, &tloc, 0) != inode->i_ino)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700794 goto end_rmdir;
795 retval = -ENOTEMPTY;
796 if (!empty_dir(inode))
797 goto end_rmdir;
798 retval = udf_delete_entry(dir, fi, &fibh, &cfi);
799 if (retval)
800 goto end_rmdir;
801 if (inode->i_nlink != 2)
802 udf_warning(inode->i_sb, "udf_rmdir",
Cyrill Gorcunovcb00ea32007-07-19 01:47:43 -0700803 "empty directory has nlink != 2 (%d)",
804 inode->i_nlink);
Dave Hansence71ec32006-09-30 23:29:06 -0700805 clear_nlink(inode);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700806 inode->i_size = 0;
Stephen Mollettc007c062007-05-08 00:31:31 -0700807 inode_dec_link_count(dir);
Marcin Slusarz4b111112008-02-08 04:20:36 -0800808 inode->i_ctime = dir->i_ctime = dir->i_mtime =
809 current_fs_time(dir->i_sb);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700810 mark_inode_dirty(dir);
811
Cyrill Gorcunov28de7942007-07-21 04:37:18 -0700812end_rmdir:
Linus Torvalds1da177e2005-04-16 15:20:36 -0700813 if (fibh.sbh != fibh.ebh)
Jan Kara3bf25cb2007-05-08 00:35:16 -0700814 brelse(fibh.ebh);
815 brelse(fibh.sbh);
Cyrill Gorcunov28de7942007-07-21 04:37:18 -0700816
817out:
Linus Torvalds1da177e2005-04-16 15:20:36 -0700818 return retval;
819}
820
Cyrill Gorcunovcb00ea32007-07-19 01:47:43 -0700821static int udf_unlink(struct inode *dir, struct dentry *dentry)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700822{
823 int retval;
Cyrill Gorcunovcb00ea32007-07-19 01:47:43 -0700824 struct inode *inode = dentry->d_inode;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700825 struct udf_fileident_bh fibh;
826 struct fileIdentDesc *fi;
827 struct fileIdentDesc cfi;
Pekka Enberg5ca4e4b2008-10-15 12:28:03 +0200828 struct kernel_lb_addr tloc;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700829
830 retval = -ENOENT;
Al Viro9fbb76c2008-10-12 00:15:17 -0400831 fi = udf_find_entry(dir, &dentry->d_name, &fibh, &cfi);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700832 if (!fi)
833 goto out;
834
835 retval = -EIO;
836 tloc = lelb_to_cpu(cfi.icb.extLocation);
Pekka Enberg97e961f2008-10-15 12:29:03 +0200837 if (udf_get_lb_pblock(dir->i_sb, &tloc, 0) != inode->i_ino)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700838 goto end_unlink;
839
Cyrill Gorcunovcb00ea32007-07-19 01:47:43 -0700840 if (!inode->i_nlink) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700841 udf_debug("Deleting nonexistent file (%lu), %d\n",
Cyrill Gorcunovcb00ea32007-07-19 01:47:43 -0700842 inode->i_ino, inode->i_nlink);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700843 inode->i_nlink = 1;
844 }
845 retval = udf_delete_entry(dir, fi, &fibh, &cfi);
846 if (retval)
847 goto end_unlink;
848 dir->i_ctime = dir->i_mtime = current_fs_time(dir->i_sb);
849 mark_inode_dirty(dir);
Dave Hansen9a53c3a2006-09-30 23:29:03 -0700850 inode_dec_link_count(inode);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700851 inode->i_ctime = dir->i_ctime;
852 retval = 0;
853
Cyrill Gorcunov28de7942007-07-21 04:37:18 -0700854end_unlink:
Linus Torvalds1da177e2005-04-16 15:20:36 -0700855 if (fibh.sbh != fibh.ebh)
Jan Kara3bf25cb2007-05-08 00:35:16 -0700856 brelse(fibh.ebh);
857 brelse(fibh.sbh);
Cyrill Gorcunov28de7942007-07-21 04:37:18 -0700858
859out:
Linus Torvalds1da177e2005-04-16 15:20:36 -0700860 return retval;
861}
862
Cyrill Gorcunovcb00ea32007-07-19 01:47:43 -0700863static int udf_symlink(struct inode *dir, struct dentry *dentry,
864 const char *symname)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700865{
Cyrill Gorcunovcb00ea32007-07-19 01:47:43 -0700866 struct inode *inode;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700867 struct pathComponent *pc;
Al Viro391e8bb2010-01-31 21:28:48 -0500868 const char *compstart;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700869 struct udf_fileident_bh fibh;
Cyrill Gorcunov28de7942007-07-21 04:37:18 -0700870 struct extent_position epos = {};
Linus Torvalds1da177e2005-04-16 15:20:36 -0700871 int eoffset, elen = 0;
872 struct fileIdentDesc *fi;
873 struct fileIdentDesc cfi;
Al Viro391e8bb2010-01-31 21:28:48 -0500874 uint8_t *ea;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700875 int err;
876 int block;
Al Viro391e8bb2010-01-31 21:28:48 -0500877 unsigned char *name = NULL;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700878 int namelen;
Marcin Slusarz48d6d8f2008-02-08 04:20:44 -0800879 struct udf_inode_info *iinfo;
Jan Karad664b6a2010-10-20 18:28:46 +0200880 struct super_block *sb = dir->i_sb;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700881
Dmitry Monakhova6c5a032010-03-04 17:32:22 +0300882 inode = udf_new_inode(dir, S_IFLNK | S_IRWXUGO, &err);
Marcin Slusarz4b111112008-02-08 04:20:36 -0800883 if (!inode)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700884 goto out;
885
Alessio Igor Bogani4d0fb622010-11-16 18:40:47 +0100886 iinfo = UDF_I(inode);
887 down_write(&iinfo->i_data_sem);
Jan Karab80697c2008-03-04 14:14:05 +0100888 name = kmalloc(UDF_NAME_LEN, GFP_NOFS);
889 if (!name) {
890 err = -ENOMEM;
891 goto out_no_entry;
892 }
893
Linus Torvalds1da177e2005-04-16 15:20:36 -0700894 inode->i_data.a_ops = &udf_symlink_aops;
Dmitry Monakhovc15d0fc2010-03-29 11:05:21 +0400895 inode->i_op = &udf_symlink_inode_operations;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700896
Marcin Slusarz48d6d8f2008-02-08 04:20:44 -0800897 if (iinfo->i_alloc_type != ICBTAG_FLAG_AD_IN_ICB) {
Pekka Enberg5ca4e4b2008-10-15 12:28:03 +0200898 struct kernel_lb_addr eloc;
Harvey Harrison78e917d2008-04-28 02:16:19 -0700899 uint32_t bsize;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700900
Jan Karad664b6a2010-10-20 18:28:46 +0200901 block = udf_new_block(sb, inode,
Marcin Slusarz48d6d8f2008-02-08 04:20:44 -0800902 iinfo->i_location.partitionReferenceNum,
903 iinfo->i_location.logicalBlockNum, &err);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700904 if (!block)
905 goto out_no_entry;
Marcin Slusarz48d6d8f2008-02-08 04:20:44 -0800906 epos.block = iinfo->i_location;
Jan Karaff116fc2007-05-08 00:35:14 -0700907 epos.offset = udf_file_entry_alloc_offset(inode);
908 epos.bh = NULL;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700909 eloc.logicalBlockNum = block;
Marcin Slusarz4b111112008-02-08 04:20:36 -0800910 eloc.partitionReferenceNum =
Marcin Slusarz48d6d8f2008-02-08 04:20:44 -0800911 iinfo->i_location.partitionReferenceNum;
Jan Karad664b6a2010-10-20 18:28:46 +0200912 bsize = sb->s_blocksize;
Harvey Harrison78e917d2008-04-28 02:16:19 -0700913 iinfo->i_lenExtents = bsize;
Pekka Enberg97e961f2008-10-15 12:29:03 +0200914 udf_add_aext(inode, &epos, &eloc, bsize, 0);
Jan Kara3bf25cb2007-05-08 00:35:16 -0700915 brelse(epos.bh);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700916
Jan Karad664b6a2010-10-20 18:28:46 +0200917 block = udf_get_pblock(sb, block,
Marcin Slusarz48d6d8f2008-02-08 04:20:44 -0800918 iinfo->i_location.partitionReferenceNum,
Marcin Slusarz4b111112008-02-08 04:20:36 -0800919 0);
Jan Karad664b6a2010-10-20 18:28:46 +0200920 epos.bh = udf_tgetblk(sb, block);
Jan Karaff116fc2007-05-08 00:35:14 -0700921 lock_buffer(epos.bh);
Jan Karad664b6a2010-10-20 18:28:46 +0200922 memset(epos.bh->b_data, 0x00, bsize);
Jan Karaff116fc2007-05-08 00:35:14 -0700923 set_buffer_uptodate(epos.bh);
924 unlock_buffer(epos.bh);
925 mark_buffer_dirty_inode(epos.bh, inode);
926 ea = epos.bh->b_data + udf_ext0_offset(inode);
Marcin Slusarz48d6d8f2008-02-08 04:20:44 -0800927 } else
928 ea = iinfo->i_ext.i_data + iinfo->i_lenEAttr;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700929
Jan Karad664b6a2010-10-20 18:28:46 +0200930 eoffset = sb->s_blocksize - udf_ext0_offset(inode);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700931 pc = (struct pathComponent *)ea;
932
Cyrill Gorcunovcb00ea32007-07-19 01:47:43 -0700933 if (*symname == '/') {
934 do {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700935 symname++;
936 } while (*symname == '/');
937
938 pc->componentType = 1;
939 pc->lengthComponentIdent = 0;
940 pc->componentFileVersionNum = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700941 elen += sizeof(struct pathComponent);
942 }
943
944 err = -ENAMETOOLONG;
945
Cyrill Gorcunovcb00ea32007-07-19 01:47:43 -0700946 while (*symname) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700947 if (elen + sizeof(struct pathComponent) > eoffset)
948 goto out_no_entry;
949
950 pc = (struct pathComponent *)(ea + elen);
951
Al Viro391e8bb2010-01-31 21:28:48 -0500952 compstart = symname;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700953
Cyrill Gorcunovcb00ea32007-07-19 01:47:43 -0700954 do {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700955 symname++;
956 } while (*symname && *symname != '/');
957
958 pc->componentType = 5;
959 pc->lengthComponentIdent = 0;
960 pc->componentFileVersionNum = 0;
Cyrill Gorcunovcb00ea32007-07-19 01:47:43 -0700961 if (compstart[0] == '.') {
962 if ((symname - compstart) == 1)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700963 pc->componentType = 4;
Marcin Slusarz4b111112008-02-08 04:20:36 -0800964 else if ((symname - compstart) == 2 &&
965 compstart[1] == '.')
Linus Torvalds1da177e2005-04-16 15:20:36 -0700966 pc->componentType = 3;
967 }
968
Cyrill Gorcunovcb00ea32007-07-19 01:47:43 -0700969 if (pc->componentType == 5) {
Jan Karad664b6a2010-10-20 18:28:46 +0200970 namelen = udf_put_filename(sb, compstart, name,
Cyrill Gorcunov28de7942007-07-21 04:37:18 -0700971 symname - compstart);
972 if (!namelen)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700973 goto out_no_entry;
974
Marcin Slusarz4b111112008-02-08 04:20:36 -0800975 if (elen + sizeof(struct pathComponent) + namelen >
976 eoffset)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700977 goto out_no_entry;
978 else
979 pc->lengthComponentIdent = namelen;
980
981 memcpy(pc->componentIdent, name, namelen);
982 }
983
984 elen += sizeof(struct pathComponent) + pc->lengthComponentIdent;
985
Cyrill Gorcunovcb00ea32007-07-19 01:47:43 -0700986 if (*symname) {
987 do {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700988 symname++;
989 } while (*symname == '/');
990 }
991 }
992
Jan Kara3bf25cb2007-05-08 00:35:16 -0700993 brelse(epos.bh);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700994 inode->i_size = elen;
Marcin Slusarz48d6d8f2008-02-08 04:20:44 -0800995 if (iinfo->i_alloc_type == ICBTAG_FLAG_AD_IN_ICB)
996 iinfo->i_lenAlloc = inode->i_size;
Jan Kara2c948b32009-12-03 13:39:28 +0100997 else
998 udf_truncate_tail_extent(inode);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700999 mark_inode_dirty(inode);
1000
Marcin Slusarz4b111112008-02-08 04:20:36 -08001001 fi = udf_add_entry(dir, dentry, &fibh, &cfi, &err);
1002 if (!fi)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001003 goto out_no_entry;
Jan Karad664b6a2010-10-20 18:28:46 +02001004 cfi.icb.extLength = cpu_to_le32(sb->s_blocksize);
Marcin Slusarz48d6d8f2008-02-08 04:20:44 -08001005 cfi.icb.extLocation = cpu_to_lelb(iinfo->i_location);
Jan Karad664b6a2010-10-20 18:28:46 +02001006 if (UDF_SB(inode->i_sb)->s_lvid_bh) {
Cyrill Gorcunov28de7942007-07-21 04:37:18 -07001007 *(__le32 *)((struct allocDescImpUse *)cfi.icb.impUse)->impUse =
Jan Karad664b6a2010-10-20 18:28:46 +02001008 cpu_to_le32(lvid_get_unique_id(sb));
Linus Torvalds1da177e2005-04-16 15:20:36 -07001009 }
1010 udf_write_fi(dir, &cfi, fi, &fibh, NULL, NULL);
Marcin Slusarzc0b34432008-02-08 04:20:42 -08001011 if (UDF_I(dir)->i_alloc_type == ICBTAG_FLAG_AD_IN_ICB)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001012 mark_inode_dirty(dir);
Alessio Igor Bogani4d0fb622010-11-16 18:40:47 +01001013 up_write(&iinfo->i_data_sem);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001014 if (fibh.sbh != fibh.ebh)
Jan Kara3bf25cb2007-05-08 00:35:16 -07001015 brelse(fibh.ebh);
1016 brelse(fibh.sbh);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001017 d_instantiate(dentry, inode);
1018 err = 0;
1019
Cyrill Gorcunov28de7942007-07-21 04:37:18 -07001020out:
Jan Karab80697c2008-03-04 14:14:05 +01001021 kfree(name);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001022 return err;
1023
Cyrill Gorcunov28de7942007-07-21 04:37:18 -07001024out_no_entry:
Alessio Igor Bogani4d0fb622010-11-16 18:40:47 +01001025 up_write(&iinfo->i_data_sem);
Dave Hansen9a53c3a2006-09-30 23:29:03 -07001026 inode_dec_link_count(inode);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001027 iput(inode);
1028 goto out;
1029}
1030
Cyrill Gorcunovcb00ea32007-07-19 01:47:43 -07001031static int udf_link(struct dentry *old_dentry, struct inode *dir,
1032 struct dentry *dentry)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001033{
1034 struct inode *inode = old_dentry->d_inode;
1035 struct udf_fileident_bh fibh;
1036 struct fileIdentDesc cfi, *fi;
1037 int err;
1038
Al Viro810c1b2e2011-03-02 10:15:26 -05001039 if (inode->i_nlink >= UDF_MAX_LINKS)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001040 return -EMLINK;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001041
Marcin Slusarz4b111112008-02-08 04:20:36 -08001042 fi = udf_add_entry(dir, dentry, &fibh, &cfi, &err);
1043 if (!fi) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001044 return err;
1045 }
1046 cfi.icb.extLength = cpu_to_le32(inode->i_sb->s_blocksize);
Marcin Slusarzc0b34432008-02-08 04:20:42 -08001047 cfi.icb.extLocation = cpu_to_lelb(UDF_I(inode)->i_location);
Jan Karad664b6a2010-10-20 18:28:46 +02001048 if (UDF_SB(inode->i_sb)->s_lvid_bh) {
Cyrill Gorcunov28de7942007-07-21 04:37:18 -07001049 *(__le32 *)((struct allocDescImpUse *)cfi.icb.impUse)->impUse =
Jan Karad664b6a2010-10-20 18:28:46 +02001050 cpu_to_le32(lvid_get_unique_id(inode->i_sb));
Linus Torvalds1da177e2005-04-16 15:20:36 -07001051 }
1052 udf_write_fi(dir, &cfi, fi, &fibh, NULL, NULL);
Marcin Slusarzc0b34432008-02-08 04:20:42 -08001053 if (UDF_I(dir)->i_alloc_type == ICBTAG_FLAG_AD_IN_ICB)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001054 mark_inode_dirty(dir);
Cyrill Gorcunov28de7942007-07-21 04:37:18 -07001055
Linus Torvalds1da177e2005-04-16 15:20:36 -07001056 if (fibh.sbh != fibh.ebh)
Jan Kara3bf25cb2007-05-08 00:35:16 -07001057 brelse(fibh.ebh);
1058 brelse(fibh.sbh);
Dave Hansend8c76e62006-09-30 23:29:04 -07001059 inc_nlink(inode);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001060 inode->i_ctime = current_fs_time(inode->i_sb);
1061 mark_inode_dirty(inode);
Al Viro7de9c6e2010-10-23 11:11:40 -04001062 ihold(inode);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001063 d_instantiate(dentry, inode);
Cyrill Gorcunov28de7942007-07-21 04:37:18 -07001064
Linus Torvalds1da177e2005-04-16 15:20:36 -07001065 return 0;
1066}
1067
1068/* Anybody can rename anything with this: the permission checks are left to the
1069 * higher-level routines.
1070 */
Cyrill Gorcunovcb00ea32007-07-19 01:47:43 -07001071static int udf_rename(struct inode *old_dir, struct dentry *old_dentry,
1072 struct inode *new_dir, struct dentry *new_dentry)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001073{
Cyrill Gorcunovcb00ea32007-07-19 01:47:43 -07001074 struct inode *old_inode = old_dentry->d_inode;
1075 struct inode *new_inode = new_dentry->d_inode;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001076 struct udf_fileident_bh ofibh, nfibh;
Marcin Slusarz4b111112008-02-08 04:20:36 -08001077 struct fileIdentDesc *ofi = NULL, *nfi = NULL, *dir_fi = NULL;
1078 struct fileIdentDesc ocfi, ncfi;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001079 struct buffer_head *dir_bh = NULL;
1080 int retval = -ENOENT;
Pekka Enberg5ca4e4b2008-10-15 12:28:03 +02001081 struct kernel_lb_addr tloc;
Marcin Slusarz48d6d8f2008-02-08 04:20:44 -08001082 struct udf_inode_info *old_iinfo = UDF_I(old_inode);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001083
Al Viro9fbb76c2008-10-12 00:15:17 -04001084 ofi = udf_find_entry(old_dir, &old_dentry->d_name, &ofibh, &ocfi);
Marcin Slusarz4b111112008-02-08 04:20:36 -08001085 if (ofi) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001086 if (ofibh.sbh != ofibh.ebh)
Jan Kara3bf25cb2007-05-08 00:35:16 -07001087 brelse(ofibh.ebh);
1088 brelse(ofibh.sbh);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001089 }
1090 tloc = lelb_to_cpu(ocfi.icb.extLocation);
Pekka Enberg97e961f2008-10-15 12:29:03 +02001091 if (!ofi || udf_get_lb_pblock(old_dir->i_sb, &tloc, 0)
Cyrill Gorcunovcb00ea32007-07-19 01:47:43 -07001092 != old_inode->i_ino)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001093 goto end_rename;
1094
Al Viro9fbb76c2008-10-12 00:15:17 -04001095 nfi = udf_find_entry(new_dir, &new_dentry->d_name, &nfibh, &ncfi);
Cyrill Gorcunovcb00ea32007-07-19 01:47:43 -07001096 if (nfi) {
1097 if (!new_inode) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001098 if (nfibh.sbh != nfibh.ebh)
Jan Kara3bf25cb2007-05-08 00:35:16 -07001099 brelse(nfibh.ebh);
1100 brelse(nfibh.sbh);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001101 nfi = NULL;
1102 }
1103 }
Cyrill Gorcunovcb00ea32007-07-19 01:47:43 -07001104 if (S_ISDIR(old_inode->i_mode)) {
Marcin Slusarz7f3fbd02008-02-08 04:20:49 -08001105 int offset = udf_ext0_offset(old_inode);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001106
Cyrill Gorcunovcb00ea32007-07-19 01:47:43 -07001107 if (new_inode) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001108 retval = -ENOTEMPTY;
1109 if (!empty_dir(new_inode))
1110 goto end_rename;
1111 }
1112 retval = -EIO;
Marcin Slusarz48d6d8f2008-02-08 04:20:44 -08001113 if (old_iinfo->i_alloc_type == ICBTAG_FLAG_AD_IN_ICB) {
Marcin Slusarz4b111112008-02-08 04:20:36 -08001114 dir_fi = udf_get_fileident(
Marcin Slusarz48d6d8f2008-02-08 04:20:44 -08001115 old_iinfo->i_ext.i_data -
1116 (old_iinfo->i_efe ?
Marcin Slusarz4b111112008-02-08 04:20:36 -08001117 sizeof(struct extendedFileEntry) :
1118 sizeof(struct fileEntry)),
1119 old_inode->i_sb->s_blocksize, &offset);
Cyrill Gorcunovcb00ea32007-07-19 01:47:43 -07001120 } else {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001121 dir_bh = udf_bread(old_inode, 0, 0, &retval);
1122 if (!dir_bh)
1123 goto end_rename;
Marcin Slusarz4b111112008-02-08 04:20:36 -08001124 dir_fi = udf_get_fileident(dir_bh->b_data,
1125 old_inode->i_sb->s_blocksize, &offset);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001126 }
1127 if (!dir_fi)
1128 goto end_rename;
1129 tloc = lelb_to_cpu(dir_fi->icb.extLocation);
Pekka Enberg97e961f2008-10-15 12:29:03 +02001130 if (udf_get_lb_pblock(old_inode->i_sb, &tloc, 0) !=
Marcin Slusarz4b111112008-02-08 04:20:36 -08001131 old_dir->i_ino)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001132 goto end_rename;
1133
1134 retval = -EMLINK;
Al Viro810c1b2e2011-03-02 10:15:26 -05001135 if (!new_inode && new_dir->i_nlink >= UDF_MAX_LINKS)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001136 goto end_rename;
1137 }
Cyrill Gorcunovcb00ea32007-07-19 01:47:43 -07001138 if (!nfi) {
Marcin Slusarz4b111112008-02-08 04:20:36 -08001139 nfi = udf_add_entry(new_dir, new_dentry, &nfibh, &ncfi,
1140 &retval);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001141 if (!nfi)
1142 goto end_rename;
1143 }
1144
1145 /*
1146 * Like most other Unix systems, set the ctime for inodes on a
1147 * rename.
1148 */
1149 old_inode->i_ctime = current_fs_time(old_inode->i_sb);
1150 mark_inode_dirty(old_inode);
1151
1152 /*
1153 * ok, that's it
1154 */
1155 ncfi.fileVersionNum = ocfi.fileVersionNum;
1156 ncfi.fileCharacteristics = ocfi.fileCharacteristics;
Pekka Enberg5ca4e4b2008-10-15 12:28:03 +02001157 memcpy(&(ncfi.icb), &(ocfi.icb), sizeof(struct long_ad));
Linus Torvalds1da177e2005-04-16 15:20:36 -07001158 udf_write_fi(new_dir, &ncfi, nfi, &nfibh, NULL, NULL);
1159
1160 /* The old fid may have moved - find it again */
Al Viro9fbb76c2008-10-12 00:15:17 -04001161 ofi = udf_find_entry(old_dir, &old_dentry->d_name, &ofibh, &ocfi);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001162 udf_delete_entry(old_dir, ofi, &ofibh, &ocfi);
1163
Cyrill Gorcunovcb00ea32007-07-19 01:47:43 -07001164 if (new_inode) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001165 new_inode->i_ctime = current_fs_time(new_inode->i_sb);
Dave Hansen9a53c3a2006-09-30 23:29:03 -07001166 inode_dec_link_count(new_inode);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001167 }
1168 old_dir->i_ctime = old_dir->i_mtime = current_fs_time(old_dir->i_sb);
1169 mark_inode_dirty(old_dir);
1170
Cyrill Gorcunovcb00ea32007-07-19 01:47:43 -07001171 if (dir_fi) {
Marcin Slusarzc0b34432008-02-08 04:20:42 -08001172 dir_fi->icb.extLocation = cpu_to_lelb(UDF_I(new_dir)->i_location);
Marcin Slusarz4b111112008-02-08 04:20:36 -08001173 udf_update_tag((char *)dir_fi,
1174 (sizeof(struct fileIdentDesc) +
1175 le16_to_cpu(dir_fi->lengthOfImpUse) + 3) & ~3);
Marcin Slusarz48d6d8f2008-02-08 04:20:44 -08001176 if (old_iinfo->i_alloc_type == ICBTAG_FLAG_AD_IN_ICB)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001177 mark_inode_dirty(old_inode);
Marcin Slusarz4b111112008-02-08 04:20:36 -08001178 else
Linus Torvalds1da177e2005-04-16 15:20:36 -07001179 mark_buffer_dirty_inode(dir_bh, old_inode);
Marcin Slusarz4b111112008-02-08 04:20:36 -08001180
Dave Hansen9a53c3a2006-09-30 23:29:03 -07001181 inode_dec_link_count(old_dir);
Marcin Slusarz4b111112008-02-08 04:20:36 -08001182 if (new_inode)
Dave Hansen9a53c3a2006-09-30 23:29:03 -07001183 inode_dec_link_count(new_inode);
Marcin Slusarz4b111112008-02-08 04:20:36 -08001184 else {
Dave Hansend8c76e62006-09-30 23:29:04 -07001185 inc_nlink(new_dir);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001186 mark_inode_dirty(new_dir);
1187 }
1188 }
1189
Cyrill Gorcunovcb00ea32007-07-19 01:47:43 -07001190 if (ofi) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001191 if (ofibh.sbh != ofibh.ebh)
Jan Kara3bf25cb2007-05-08 00:35:16 -07001192 brelse(ofibh.ebh);
1193 brelse(ofibh.sbh);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001194 }
1195
1196 retval = 0;
1197
Cyrill Gorcunov28de7942007-07-21 04:37:18 -07001198end_rename:
Jan Kara3bf25cb2007-05-08 00:35:16 -07001199 brelse(dir_bh);
Cyrill Gorcunovcb00ea32007-07-19 01:47:43 -07001200 if (nfi) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001201 if (nfibh.sbh != nfibh.ebh)
Jan Kara3bf25cb2007-05-08 00:35:16 -07001202 brelse(nfibh.ebh);
1203 brelse(nfibh.sbh);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001204 }
Cyrill Gorcunov28de7942007-07-21 04:37:18 -07001205
Linus Torvalds1da177e2005-04-16 15:20:36 -07001206 return retval;
1207}
1208
Rasmus Rohde221e5832008-04-30 17:22:06 +02001209static struct dentry *udf_get_parent(struct dentry *child)
1210{
Pekka Enberg97e961f2008-10-15 12:29:03 +02001211 struct kernel_lb_addr tloc;
Rasmus Rohde221e5832008-04-30 17:22:06 +02001212 struct inode *inode = NULL;
Al Viro9fbb76c2008-10-12 00:15:17 -04001213 struct qstr dotdot = {.name = "..", .len = 2};
Rasmus Rohde221e5832008-04-30 17:22:06 +02001214 struct fileIdentDesc cfi;
1215 struct udf_fileident_bh fibh;
1216
Rasmus Rohde221e5832008-04-30 17:22:06 +02001217 if (!udf_find_entry(child->d_inode, &dotdot, &fibh, &cfi))
1218 goto out_unlock;
1219
1220 if (fibh.sbh != fibh.ebh)
1221 brelse(fibh.ebh);
1222 brelse(fibh.sbh);
1223
Pekka Enberg97e961f2008-10-15 12:29:03 +02001224 tloc = lelb_to_cpu(cfi.icb.extLocation);
1225 inode = udf_iget(child->d_inode->i_sb, &tloc);
Rasmus Rohde221e5832008-04-30 17:22:06 +02001226 if (!inode)
1227 goto out_unlock;
Rasmus Rohde221e5832008-04-30 17:22:06 +02001228
Christoph Hellwig44003722008-08-11 15:49:04 +02001229 return d_obtain_alias(inode);
Rasmus Rohde221e5832008-04-30 17:22:06 +02001230out_unlock:
Rasmus Rohde221e5832008-04-30 17:22:06 +02001231 return ERR_PTR(-EACCES);
1232}
1233
1234
1235static struct dentry *udf_nfs_get_inode(struct super_block *sb, u32 block,
1236 u16 partref, __u32 generation)
1237{
1238 struct inode *inode;
Pekka Enberg5ca4e4b2008-10-15 12:28:03 +02001239 struct kernel_lb_addr loc;
Rasmus Rohde221e5832008-04-30 17:22:06 +02001240
1241 if (block == 0)
1242 return ERR_PTR(-ESTALE);
1243
1244 loc.logicalBlockNum = block;
1245 loc.partitionReferenceNum = partref;
Pekka Enberg97e961f2008-10-15 12:29:03 +02001246 inode = udf_iget(sb, &loc);
Rasmus Rohde221e5832008-04-30 17:22:06 +02001247
1248 if (inode == NULL)
1249 return ERR_PTR(-ENOMEM);
1250
1251 if (generation && inode->i_generation != generation) {
1252 iput(inode);
1253 return ERR_PTR(-ESTALE);
1254 }
Christoph Hellwig44003722008-08-11 15:49:04 +02001255 return d_obtain_alias(inode);
Rasmus Rohde221e5832008-04-30 17:22:06 +02001256}
1257
1258static struct dentry *udf_fh_to_dentry(struct super_block *sb,
1259 struct fid *fid, int fh_len, int fh_type)
1260{
1261 if ((fh_len != 3 && fh_len != 5) ||
1262 (fh_type != FILEID_UDF_WITH_PARENT &&
1263 fh_type != FILEID_UDF_WITHOUT_PARENT))
1264 return NULL;
1265
1266 return udf_nfs_get_inode(sb, fid->udf.block, fid->udf.partref,
1267 fid->udf.generation);
1268}
1269
1270static struct dentry *udf_fh_to_parent(struct super_block *sb,
1271 struct fid *fid, int fh_len, int fh_type)
1272{
1273 if (fh_len != 5 || fh_type != FILEID_UDF_WITH_PARENT)
1274 return NULL;
1275
1276 return udf_nfs_get_inode(sb, fid->udf.parent_block,
1277 fid->udf.parent_partref,
1278 fid->udf.parent_generation);
1279}
1280static int udf_encode_fh(struct dentry *de, __u32 *fh, int *lenp,
1281 int connectable)
1282{
1283 int len = *lenp;
1284 struct inode *inode = de->d_inode;
Pekka Enberg5ca4e4b2008-10-15 12:28:03 +02001285 struct kernel_lb_addr location = UDF_I(inode)->i_location;
Rasmus Rohde221e5832008-04-30 17:22:06 +02001286 struct fid *fid = (struct fid *)fh;
1287 int type = FILEID_UDF_WITHOUT_PARENT;
1288
Aneesh Kumar K.V5fe0c232011-01-29 18:43:25 +05301289 if (connectable && (len < 5)) {
1290 *lenp = 5;
Rasmus Rohde221e5832008-04-30 17:22:06 +02001291 return 255;
Aneesh Kumar K.V5fe0c232011-01-29 18:43:25 +05301292 } else if (len < 3) {
1293 *lenp = 3;
1294 return 255;
1295 }
Rasmus Rohde221e5832008-04-30 17:22:06 +02001296
1297 *lenp = 3;
1298 fid->udf.block = location.logicalBlockNum;
1299 fid->udf.partref = location.partitionReferenceNum;
1300 fid->udf.generation = inode->i_generation;
1301
1302 if (connectable && !S_ISDIR(inode->i_mode)) {
1303 spin_lock(&de->d_lock);
1304 inode = de->d_parent->d_inode;
1305 location = UDF_I(inode)->i_location;
1306 fid->udf.parent_block = location.logicalBlockNum;
1307 fid->udf.parent_partref = location.partitionReferenceNum;
1308 fid->udf.parent_generation = inode->i_generation;
1309 spin_unlock(&de->d_lock);
1310 *lenp = 5;
1311 type = FILEID_UDF_WITH_PARENT;
1312 }
1313
1314 return type;
1315}
1316
1317const struct export_operations udf_export_ops = {
1318 .encode_fh = udf_encode_fh,
1319 .fh_to_dentry = udf_fh_to_dentry,
1320 .fh_to_parent = udf_fh_to_parent,
1321 .get_parent = udf_get_parent,
1322};
1323
Arjan van de Venc5ef1c42007-02-12 00:55:40 -08001324const struct inode_operations udf_dir_inode_operations = {
Cyrill Gorcunov28de7942007-07-21 04:37:18 -07001325 .lookup = udf_lookup,
1326 .create = udf_create,
1327 .link = udf_link,
1328 .unlink = udf_unlink,
1329 .symlink = udf_symlink,
1330 .mkdir = udf_mkdir,
1331 .rmdir = udf_rmdir,
1332 .mknod = udf_mknod,
1333 .rename = udf_rename,
Linus Torvalds1da177e2005-04-16 15:20:36 -07001334};
Dmitry Monakhovc15d0fc2010-03-29 11:05:21 +04001335const struct inode_operations udf_symlink_inode_operations = {
1336 .readlink = generic_readlink,
1337 .follow_link = page_follow_link_light,
1338 .put_link = page_put_link,
Dmitry Monakhovc15d0fc2010-03-29 11:05:21 +04001339};