4 * Copyright (C) International Business Machines Corp., 2002,2010
5 * Author(s): Steve French (sfrench@us.ibm.com)
7 * This library is free software; you can redistribute it and/or modify
8 * it under the terms of the GNU Lesser General Public License as published
9 * by the Free Software Foundation; either version 2.1 of the License, or
10 * (at your option) any later version.
12 * This library is distributed in the hope that it will be useful,
13 * but WITHOUT ANY WARRANTY; without even the implied warranty of
14 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See
15 * the GNU Lesser General Public License for more details.
17 * You should have received a copy of the GNU Lesser General Public License
18 * along with this library; if not, write to the Free Software
19 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
22 #include <linux/stat.h>
23 #include <linux/slab.h>
24 #include <linux/pagemap.h>
25 #include <asm/div64.h>
29 #include "cifsproto.h"
30 #include "cifs_debug.h"
31 #include "cifs_fs_sb.h"
35 static void cifs_set_ops(struct inode
*inode
)
37 struct cifs_sb_info
*cifs_sb
= CIFS_SB(inode
->i_sb
);
39 switch (inode
->i_mode
& S_IFMT
) {
41 inode
->i_op
= &cifs_file_inode_ops
;
42 if (cifs_sb
->mnt_cifs_flags
& CIFS_MOUNT_DIRECT_IO
) {
43 if (cifs_sb
->mnt_cifs_flags
& CIFS_MOUNT_NO_BRL
)
44 inode
->i_fop
= &cifs_file_direct_nobrl_ops
;
46 inode
->i_fop
= &cifs_file_direct_ops
;
47 } else if (cifs_sb
->mnt_cifs_flags
& CIFS_MOUNT_STRICT_IO
) {
48 if (cifs_sb
->mnt_cifs_flags
& CIFS_MOUNT_NO_BRL
)
49 inode
->i_fop
= &cifs_file_strict_nobrl_ops
;
51 inode
->i_fop
= &cifs_file_strict_ops
;
52 } else if (cifs_sb
->mnt_cifs_flags
& CIFS_MOUNT_NO_BRL
)
53 inode
->i_fop
= &cifs_file_nobrl_ops
;
54 else { /* not direct, send byte range locks */
55 inode
->i_fop
= &cifs_file_ops
;
58 /* check if server can support readpages */
59 if (cifs_sb_master_tcon(cifs_sb
)->ses
->server
->maxBuf
<
60 PAGE_CACHE_SIZE
+ MAX_CIFS_HDR_SIZE
)
61 inode
->i_data
.a_ops
= &cifs_addr_ops_smallbuf
;
63 inode
->i_data
.a_ops
= &cifs_addr_ops
;
66 #ifdef CONFIG_CIFS_DFS_UPCALL
67 if (IS_AUTOMOUNT(inode
)) {
68 inode
->i_op
= &cifs_dfs_referral_inode_operations
;
70 #else /* NO DFS support, treat as a directory */
73 inode
->i_op
= &cifs_dir_inode_ops
;
74 inode
->i_fop
= &cifs_dir_ops
;
78 inode
->i_op
= &cifs_symlink_inode_ops
;
81 init_special_inode(inode
, inode
->i_mode
, inode
->i_rdev
);
86 /* check inode attributes against fattr. If they don't match, tag the
87 * inode for cache invalidation
90 cifs_revalidate_cache(struct inode
*inode
, struct cifs_fattr
*fattr
)
92 struct cifsInodeInfo
*cifs_i
= CIFS_I(inode
);
94 cifs_dbg(FYI
, "%s: revalidating inode %llu\n",
95 __func__
, cifs_i
->uniqueid
);
97 if (inode
->i_state
& I_NEW
) {
98 cifs_dbg(FYI
, "%s: inode %llu is new\n",
99 __func__
, cifs_i
->uniqueid
);
103 /* don't bother with revalidation if we have an oplock */
104 if (CIFS_CACHE_READ(cifs_i
)) {
105 cifs_dbg(FYI
, "%s: inode %llu is oplocked\n",
106 __func__
, cifs_i
->uniqueid
);
110 /* revalidate if mtime or size have changed */
111 if (timespec_equal(&inode
->i_mtime
, &fattr
->cf_mtime
) &&
112 cifs_i
->server_eof
== fattr
->cf_eof
) {
113 cifs_dbg(FYI
, "%s: inode %llu is unchanged\n",
114 __func__
, cifs_i
->uniqueid
);
118 cifs_dbg(FYI
, "%s: invalidating inode %llu mapping\n",
119 __func__
, cifs_i
->uniqueid
);
120 cifs_i
->invalid_mapping
= true;
124 * copy nlink to the inode, unless it wasn't provided. Provide
125 * sane values if we don't have an existing one and none was provided
128 cifs_nlink_fattr_to_inode(struct inode
*inode
, struct cifs_fattr
*fattr
)
131 * if we're in a situation where we can't trust what we
132 * got from the server (readdir, some non-unix cases)
133 * fake reasonable values
135 if (fattr
->cf_flags
& CIFS_FATTR_UNKNOWN_NLINK
) {
136 /* only provide fake values on a new inode */
137 if (inode
->i_state
& I_NEW
) {
138 if (fattr
->cf_cifsattrs
& ATTR_DIRECTORY
)
146 /* we trust the server, so update it */
147 set_nlink(inode
, fattr
->cf_nlink
);
150 /* populate an inode with info from a cifs_fattr struct */
152 cifs_fattr_to_inode(struct inode
*inode
, struct cifs_fattr
*fattr
)
154 struct cifsInodeInfo
*cifs_i
= CIFS_I(inode
);
155 struct cifs_sb_info
*cifs_sb
= CIFS_SB(inode
->i_sb
);
157 cifs_revalidate_cache(inode
, fattr
);
159 spin_lock(&inode
->i_lock
);
160 inode
->i_atime
= fattr
->cf_atime
;
161 inode
->i_mtime
= fattr
->cf_mtime
;
162 inode
->i_ctime
= fattr
->cf_ctime
;
163 inode
->i_rdev
= fattr
->cf_rdev
;
164 cifs_nlink_fattr_to_inode(inode
, fattr
);
165 inode
->i_uid
= fattr
->cf_uid
;
166 inode
->i_gid
= fattr
->cf_gid
;
168 /* if dynperm is set, don't clobber existing mode */
169 if (inode
->i_state
& I_NEW
||
170 !(cifs_sb
->mnt_cifs_flags
& CIFS_MOUNT_DYNPERM
))
171 inode
->i_mode
= fattr
->cf_mode
;
173 cifs_i
->cifsAttrs
= fattr
->cf_cifsattrs
;
175 if (fattr
->cf_flags
& CIFS_FATTR_NEED_REVAL
)
178 cifs_i
->time
= jiffies
;
180 cifs_i
->delete_pending
= fattr
->cf_flags
& CIFS_FATTR_DELETE_PENDING
;
182 cifs_i
->server_eof
= fattr
->cf_eof
;
184 * Can't safely change the file size here if the client is writing to
185 * it due to potential races.
187 if (is_size_safe_to_change(cifs_i
, fattr
->cf_eof
)) {
188 i_size_write(inode
, fattr
->cf_eof
);
191 * i_blocks is not related to (i_size / i_blksize),
192 * but instead 512 byte (2**9) size is required for
193 * calculating num blocks.
195 inode
->i_blocks
= (512 - 1 + fattr
->cf_bytes
) >> 9;
197 spin_unlock(&inode
->i_lock
);
199 if (fattr
->cf_flags
& CIFS_FATTR_DFS_REFERRAL
)
200 inode
->i_flags
|= S_AUTOMOUNT
;
201 if (inode
->i_state
& I_NEW
)
206 cifs_fill_uniqueid(struct super_block
*sb
, struct cifs_fattr
*fattr
)
208 struct cifs_sb_info
*cifs_sb
= CIFS_SB(sb
);
210 if (cifs_sb
->mnt_cifs_flags
& CIFS_MOUNT_SERVER_INUM
)
213 fattr
->cf_uniqueid
= iunique(sb
, ROOT_I
);
216 /* Fill a cifs_fattr struct with info from FILE_UNIX_BASIC_INFO. */
218 cifs_unix_basic_to_fattr(struct cifs_fattr
*fattr
, FILE_UNIX_BASIC_INFO
*info
,
219 struct cifs_sb_info
*cifs_sb
)
221 memset(fattr
, 0, sizeof(*fattr
));
222 fattr
->cf_uniqueid
= le64_to_cpu(info
->UniqueId
);
223 fattr
->cf_bytes
= le64_to_cpu(info
->NumOfBytes
);
224 fattr
->cf_eof
= le64_to_cpu(info
->EndOfFile
);
226 fattr
->cf_atime
= cifs_NTtimeToUnix(info
->LastAccessTime
);
227 fattr
->cf_mtime
= cifs_NTtimeToUnix(info
->LastModificationTime
);
228 fattr
->cf_ctime
= cifs_NTtimeToUnix(info
->LastStatusChange
);
229 fattr
->cf_mode
= le64_to_cpu(info
->Permissions
);
232 * Since we set the inode type below we need to mask off
233 * to avoid strange results if bits set above.
235 fattr
->cf_mode
&= ~S_IFMT
;
236 switch (le32_to_cpu(info
->Type
)) {
238 fattr
->cf_mode
|= S_IFREG
;
239 fattr
->cf_dtype
= DT_REG
;
242 fattr
->cf_mode
|= S_IFLNK
;
243 fattr
->cf_dtype
= DT_LNK
;
246 fattr
->cf_mode
|= S_IFDIR
;
247 fattr
->cf_dtype
= DT_DIR
;
250 fattr
->cf_mode
|= S_IFCHR
;
251 fattr
->cf_dtype
= DT_CHR
;
252 fattr
->cf_rdev
= MKDEV(le64_to_cpu(info
->DevMajor
),
253 le64_to_cpu(info
->DevMinor
) & MINORMASK
);
256 fattr
->cf_mode
|= S_IFBLK
;
257 fattr
->cf_dtype
= DT_BLK
;
258 fattr
->cf_rdev
= MKDEV(le64_to_cpu(info
->DevMajor
),
259 le64_to_cpu(info
->DevMinor
) & MINORMASK
);
262 fattr
->cf_mode
|= S_IFIFO
;
263 fattr
->cf_dtype
= DT_FIFO
;
266 fattr
->cf_mode
|= S_IFSOCK
;
267 fattr
->cf_dtype
= DT_SOCK
;
270 /* safest to call it a file if we do not know */
271 fattr
->cf_mode
|= S_IFREG
;
272 fattr
->cf_dtype
= DT_REG
;
273 cifs_dbg(FYI
, "unknown type %d\n", le32_to_cpu(info
->Type
));
277 fattr
->cf_uid
= cifs_sb
->mnt_uid
;
278 if (!(cifs_sb
->mnt_cifs_flags
& CIFS_MOUNT_OVERR_UID
)) {
279 u64 id
= le64_to_cpu(info
->Uid
);
280 if (id
< ((uid_t
)-1)) {
281 kuid_t uid
= make_kuid(&init_user_ns
, id
);
287 fattr
->cf_gid
= cifs_sb
->mnt_gid
;
288 if (!(cifs_sb
->mnt_cifs_flags
& CIFS_MOUNT_OVERR_GID
)) {
289 u64 id
= le64_to_cpu(info
->Gid
);
290 if (id
< ((gid_t
)-1)) {
291 kgid_t gid
= make_kgid(&init_user_ns
, id
);
297 fattr
->cf_nlink
= le64_to_cpu(info
->Nlinks
);
301 * Fill a cifs_fattr struct with fake inode info.
303 * Needed to setup cifs_fattr data for the directory which is the
304 * junction to the new submount (ie to setup the fake directory
305 * which represents a DFS referral).
308 cifs_create_dfs_fattr(struct cifs_fattr
*fattr
, struct super_block
*sb
)
310 struct cifs_sb_info
*cifs_sb
= CIFS_SB(sb
);
312 cifs_dbg(FYI
, "creating fake fattr for DFS referral\n");
314 memset(fattr
, 0, sizeof(*fattr
));
315 fattr
->cf_mode
= S_IFDIR
| S_IXUGO
| S_IRWXU
;
316 fattr
->cf_uid
= cifs_sb
->mnt_uid
;
317 fattr
->cf_gid
= cifs_sb
->mnt_gid
;
318 fattr
->cf_atime
= CURRENT_TIME
;
319 fattr
->cf_ctime
= CURRENT_TIME
;
320 fattr
->cf_mtime
= CURRENT_TIME
;
322 fattr
->cf_flags
|= CIFS_FATTR_DFS_REFERRAL
;
326 cifs_get_file_info_unix(struct file
*filp
)
330 FILE_UNIX_BASIC_INFO find_data
;
331 struct cifs_fattr fattr
;
332 struct inode
*inode
= file_inode(filp
);
333 struct cifs_sb_info
*cifs_sb
= CIFS_SB(inode
->i_sb
);
334 struct cifsFileInfo
*cfile
= filp
->private_data
;
335 struct cifs_tcon
*tcon
= tlink_tcon(cfile
->tlink
);
338 rc
= CIFSSMBUnixQFileInfo(xid
, tcon
, cfile
->fid
.netfid
, &find_data
);
340 cifs_unix_basic_to_fattr(&fattr
, &find_data
, cifs_sb
);
341 } else if (rc
== -EREMOTE
) {
342 cifs_create_dfs_fattr(&fattr
, inode
->i_sb
);
346 cifs_fattr_to_inode(inode
, &fattr
);
351 int cifs_get_inode_info_unix(struct inode
**pinode
,
352 const unsigned char *full_path
,
353 struct super_block
*sb
, unsigned int xid
)
356 FILE_UNIX_BASIC_INFO find_data
;
357 struct cifs_fattr fattr
;
358 struct cifs_tcon
*tcon
;
359 struct tcon_link
*tlink
;
360 struct cifs_sb_info
*cifs_sb
= CIFS_SB(sb
);
362 cifs_dbg(FYI
, "Getting info on %s\n", full_path
);
364 tlink
= cifs_sb_tlink(cifs_sb
);
366 return PTR_ERR(tlink
);
367 tcon
= tlink_tcon(tlink
);
369 /* could have done a find first instead but this returns more info */
370 rc
= CIFSSMBUnixQPathInfo(xid
, tcon
, full_path
, &find_data
,
371 cifs_sb
->local_nls
, cifs_sb
->mnt_cifs_flags
&
372 CIFS_MOUNT_MAP_SPECIAL_CHR
);
373 cifs_put_tlink(tlink
);
376 cifs_unix_basic_to_fattr(&fattr
, &find_data
, cifs_sb
);
377 } else if (rc
== -EREMOTE
) {
378 cifs_create_dfs_fattr(&fattr
, sb
);
384 /* check for Minshall+French symlinks */
385 if (cifs_sb
->mnt_cifs_flags
& CIFS_MOUNT_MF_SYMLINKS
) {
386 int tmprc
= check_mf_symlink(xid
, tcon
, cifs_sb
, &fattr
,
389 cifs_dbg(FYI
, "check_mf_symlink: %d\n", tmprc
);
392 if (*pinode
== NULL
) {
394 cifs_fill_uniqueid(sb
, &fattr
);
395 *pinode
= cifs_iget(sb
, &fattr
);
399 /* we already have inode, update it */
400 cifs_fattr_to_inode(*pinode
, &fattr
);
407 cifs_sfu_type(struct cifs_fattr
*fattr
, const char *path
,
408 struct cifs_sb_info
*cifs_sb
, unsigned int xid
)
412 struct tcon_link
*tlink
;
413 struct cifs_tcon
*tcon
;
415 struct cifs_open_parms oparms
;
416 struct cifs_io_parms io_parms
;
418 unsigned int bytes_read
;
420 int buf_type
= CIFS_NO_BUFFER
;
424 fattr
->cf_mode
&= ~S_IFMT
;
426 if (fattr
->cf_eof
== 0) {
427 fattr
->cf_mode
|= S_IFIFO
;
428 fattr
->cf_dtype
= DT_FIFO
;
430 } else if (fattr
->cf_eof
< 8) {
431 fattr
->cf_mode
|= S_IFREG
;
432 fattr
->cf_dtype
= DT_REG
;
433 return -EINVAL
; /* EOPNOTSUPP? */
436 tlink
= cifs_sb_tlink(cifs_sb
);
438 return PTR_ERR(tlink
);
439 tcon
= tlink_tcon(tlink
);
442 oparms
.cifs_sb
= cifs_sb
;
443 oparms
.desired_access
= GENERIC_READ
;
444 oparms
.create_options
= CREATE_NOT_DIR
;
445 oparms
.disposition
= FILE_OPEN
;
448 oparms
.reconnect
= false;
450 rc
= CIFS_open(xid
, &oparms
, &oplock
, NULL
);
452 cifs_put_tlink(tlink
);
457 io_parms
.netfid
= fid
.netfid
;
458 io_parms
.pid
= current
->tgid
;
459 io_parms
.tcon
= tcon
;
461 io_parms
.length
= 24;
463 rc
= CIFSSMBRead(xid
, &io_parms
, &bytes_read
, &pbuf
, &buf_type
);
464 if ((rc
== 0) && (bytes_read
>= 8)) {
465 if (memcmp("IntxBLK", pbuf
, 8) == 0) {
466 cifs_dbg(FYI
, "Block device\n");
467 fattr
->cf_mode
|= S_IFBLK
;
468 fattr
->cf_dtype
= DT_BLK
;
469 if (bytes_read
== 24) {
470 /* we have enough to decode dev num */
471 __u64 mjr
; /* major */
472 __u64 mnr
; /* minor */
473 mjr
= le64_to_cpu(*(__le64
*)(pbuf
+8));
474 mnr
= le64_to_cpu(*(__le64
*)(pbuf
+16));
475 fattr
->cf_rdev
= MKDEV(mjr
, mnr
);
477 } else if (memcmp("IntxCHR", pbuf
, 8) == 0) {
478 cifs_dbg(FYI
, "Char device\n");
479 fattr
->cf_mode
|= S_IFCHR
;
480 fattr
->cf_dtype
= DT_CHR
;
481 if (bytes_read
== 24) {
482 /* we have enough to decode dev num */
483 __u64 mjr
; /* major */
484 __u64 mnr
; /* minor */
485 mjr
= le64_to_cpu(*(__le64
*)(pbuf
+8));
486 mnr
= le64_to_cpu(*(__le64
*)(pbuf
+16));
487 fattr
->cf_rdev
= MKDEV(mjr
, mnr
);
489 } else if (memcmp("IntxLNK", pbuf
, 7) == 0) {
490 cifs_dbg(FYI
, "Symlink\n");
491 fattr
->cf_mode
|= S_IFLNK
;
492 fattr
->cf_dtype
= DT_LNK
;
494 fattr
->cf_mode
|= S_IFREG
; /* file? */
495 fattr
->cf_dtype
= DT_REG
;
499 fattr
->cf_mode
|= S_IFREG
; /* then it is a file */
500 fattr
->cf_dtype
= DT_REG
;
501 rc
= -EOPNOTSUPP
; /* or some unknown SFU type */
503 CIFSSMBClose(xid
, tcon
, fid
.netfid
);
504 cifs_put_tlink(tlink
);
508 #define SFBITS_MASK (S_ISVTX | S_ISGID | S_ISUID) /* SETFILEBITS valid bits */
511 * Fetch mode bits as provided by SFU.
513 * FIXME: Doesn't this clobber the type bit we got from cifs_sfu_type ?
515 static int cifs_sfu_mode(struct cifs_fattr
*fattr
, const unsigned char *path
,
516 struct cifs_sb_info
*cifs_sb
, unsigned int xid
)
518 #ifdef CONFIG_CIFS_XATTR
522 struct tcon_link
*tlink
;
523 struct cifs_tcon
*tcon
;
525 tlink
= cifs_sb_tlink(cifs_sb
);
527 return PTR_ERR(tlink
);
528 tcon
= tlink_tcon(tlink
);
530 if (tcon
->ses
->server
->ops
->query_all_EAs
== NULL
) {
531 cifs_put_tlink(tlink
);
535 rc
= tcon
->ses
->server
->ops
->query_all_EAs(xid
, tcon
, path
,
536 "SETFILEBITS", ea_value
, 4 /* size of buf */,
538 cifs_sb
->mnt_cifs_flags
& CIFS_MOUNT_MAP_SPECIAL_CHR
);
539 cifs_put_tlink(tlink
);
543 mode
= le32_to_cpu(*((__le32
*)ea_value
));
544 fattr
->cf_mode
&= ~SFBITS_MASK
;
545 cifs_dbg(FYI
, "special bits 0%o org mode 0%o\n",
546 mode
, fattr
->cf_mode
);
547 fattr
->cf_mode
= (mode
& SFBITS_MASK
) | fattr
->cf_mode
;
548 cifs_dbg(FYI
, "special mode bits 0%o\n", mode
);
557 /* Fill a cifs_fattr struct with info from FILE_ALL_INFO */
559 cifs_all_info_to_fattr(struct cifs_fattr
*fattr
, FILE_ALL_INFO
*info
,
560 struct cifs_sb_info
*cifs_sb
, bool adjust_tz
,
563 struct cifs_tcon
*tcon
= cifs_sb_master_tcon(cifs_sb
);
565 memset(fattr
, 0, sizeof(*fattr
));
566 fattr
->cf_cifsattrs
= le32_to_cpu(info
->Attributes
);
567 if (info
->DeletePending
)
568 fattr
->cf_flags
|= CIFS_FATTR_DELETE_PENDING
;
570 if (info
->LastAccessTime
)
571 fattr
->cf_atime
= cifs_NTtimeToUnix(info
->LastAccessTime
);
573 fattr
->cf_atime
= CURRENT_TIME
;
575 fattr
->cf_ctime
= cifs_NTtimeToUnix(info
->ChangeTime
);
576 fattr
->cf_mtime
= cifs_NTtimeToUnix(info
->LastWriteTime
);
579 fattr
->cf_ctime
.tv_sec
+= tcon
->ses
->server
->timeAdj
;
580 fattr
->cf_mtime
.tv_sec
+= tcon
->ses
->server
->timeAdj
;
583 fattr
->cf_eof
= le64_to_cpu(info
->EndOfFile
);
584 fattr
->cf_bytes
= le64_to_cpu(info
->AllocationSize
);
585 fattr
->cf_createtime
= le64_to_cpu(info
->CreationTime
);
587 fattr
->cf_nlink
= le32_to_cpu(info
->NumberOfLinks
);
590 fattr
->cf_mode
= S_IFLNK
;
591 fattr
->cf_dtype
= DT_LNK
;
592 } else if (fattr
->cf_cifsattrs
& ATTR_DIRECTORY
) {
593 fattr
->cf_mode
= S_IFDIR
| cifs_sb
->mnt_dir_mode
;
594 fattr
->cf_dtype
= DT_DIR
;
596 * Server can return wrong NumberOfLinks value for directories
597 * when Unix extensions are disabled - fake it.
600 fattr
->cf_flags
|= CIFS_FATTR_UNKNOWN_NLINK
;
602 fattr
->cf_mode
= S_IFREG
| cifs_sb
->mnt_file_mode
;
603 fattr
->cf_dtype
= DT_REG
;
605 /* clear write bits if ATTR_READONLY is set */
606 if (fattr
->cf_cifsattrs
& ATTR_READONLY
)
607 fattr
->cf_mode
&= ~(S_IWUGO
);
610 * Don't accept zero nlink from non-unix servers unless
611 * delete is pending. Instead mark it as unknown.
613 if ((fattr
->cf_nlink
< 1) && !tcon
->unix_ext
&&
614 !info
->DeletePending
) {
615 cifs_dbg(1, "bogus file nlink value %u\n",
617 fattr
->cf_flags
|= CIFS_FATTR_UNKNOWN_NLINK
;
621 fattr
->cf_uid
= cifs_sb
->mnt_uid
;
622 fattr
->cf_gid
= cifs_sb
->mnt_gid
;
626 cifs_get_file_info(struct file
*filp
)
630 FILE_ALL_INFO find_data
;
631 struct cifs_fattr fattr
;
632 struct inode
*inode
= file_inode(filp
);
633 struct cifs_sb_info
*cifs_sb
= CIFS_SB(inode
->i_sb
);
634 struct cifsFileInfo
*cfile
= filp
->private_data
;
635 struct cifs_tcon
*tcon
= tlink_tcon(cfile
->tlink
);
636 struct TCP_Server_Info
*server
= tcon
->ses
->server
;
638 if (!server
->ops
->query_file_info
)
642 rc
= server
->ops
->query_file_info(xid
, tcon
, &cfile
->fid
, &find_data
);
645 cifs_all_info_to_fattr(&fattr
, &find_data
, cifs_sb
, false,
649 cifs_create_dfs_fattr(&fattr
, inode
->i_sb
);
655 * FIXME: legacy server -- fall back to path-based call?
656 * for now, just skip revalidating and mark inode for
660 CIFS_I(inode
)->time
= 0;
666 * don't bother with SFU junk here -- just mark inode as needing
669 fattr
.cf_uniqueid
= CIFS_I(inode
)->uniqueid
;
670 fattr
.cf_flags
|= CIFS_FATTR_NEED_REVAL
;
671 cifs_fattr_to_inode(inode
, &fattr
);
678 cifs_get_inode_info(struct inode
**inode
, const char *full_path
,
679 FILE_ALL_INFO
*data
, struct super_block
*sb
, int xid
,
680 const struct cifs_fid
*fid
)
682 bool validinum
= false;
684 int rc
= 0, tmprc
= ENOSYS
;
685 struct cifs_tcon
*tcon
;
686 struct TCP_Server_Info
*server
;
687 struct tcon_link
*tlink
;
688 struct cifs_sb_info
*cifs_sb
= CIFS_SB(sb
);
690 bool adjust_tz
= false;
691 struct cifs_fattr fattr
;
692 struct cifs_search_info
*srchinf
= NULL
;
693 bool symlink
= false;
695 tlink
= cifs_sb_tlink(cifs_sb
);
697 return PTR_ERR(tlink
);
698 tcon
= tlink_tcon(tlink
);
699 server
= tcon
->ses
->server
;
701 cifs_dbg(FYI
, "Getting info on %s\n", full_path
);
703 if ((data
== NULL
) && (*inode
!= NULL
)) {
704 if (CIFS_CACHE_READ(CIFS_I(*inode
))) {
705 cifs_dbg(FYI
, "No need to revalidate cached inode sizes\n");
710 /* if inode info is not passed, get it from server */
712 if (!server
->ops
->query_path_info
) {
716 buf
= kmalloc(sizeof(FILE_ALL_INFO
), GFP_KERNEL
);
721 data
= (FILE_ALL_INFO
*)buf
;
722 rc
= server
->ops
->query_path_info(xid
, tcon
, cifs_sb
, full_path
,
723 data
, &adjust_tz
, &symlink
);
727 cifs_all_info_to_fattr(&fattr
, data
, cifs_sb
, adjust_tz
,
729 } else if (rc
== -EREMOTE
) {
730 cifs_create_dfs_fattr(&fattr
, sb
);
732 } else if (rc
== -EACCES
&& backup_cred(cifs_sb
)) {
733 srchinf
= kzalloc(sizeof(struct cifs_search_info
),
735 if (srchinf
== NULL
) {
740 srchinf
->endOfSearch
= false;
741 srchinf
->info_level
= SMB_FIND_FILE_ID_FULL_DIR_INFO
;
743 srchflgs
= CIFS_SEARCH_CLOSE_ALWAYS
|
744 CIFS_SEARCH_CLOSE_AT_END
|
745 CIFS_SEARCH_BACKUP_SEARCH
;
747 rc
= CIFSFindFirst(xid
, tcon
, full_path
,
748 cifs_sb
, NULL
, srchflgs
, srchinf
, false);
751 (FILE_ALL_INFO
*)srchinf
->srch_entries_start
;
753 cifs_dir_info_to_fattr(&fattr
,
754 (FILE_DIRECTORY_INFO
*)data
, cifs_sb
);
755 fattr
.cf_uniqueid
= le64_to_cpu(
756 ((SEARCH_ID_FULL_DIR_INFO
*)data
)->UniqueId
);
759 cifs_buf_release(srchinf
->ntwrk_buf_start
);
766 * If an inode wasn't passed in, then get the inode number
768 * Is an i_ino of zero legal? Can we use that to check if the server
769 * supports returning inode numbers? Are there other sanity checks we
770 * can use to ensure that the server is really filling in that field?
772 if (*inode
== NULL
) {
773 if (cifs_sb
->mnt_cifs_flags
& CIFS_MOUNT_SERVER_INUM
) {
774 if (validinum
== false) {
775 if (server
->ops
->get_srv_inum
)
776 tmprc
= server
->ops
->get_srv_inum(xid
,
777 tcon
, cifs_sb
, full_path
,
778 &fattr
.cf_uniqueid
, data
);
780 cifs_dbg(FYI
, "GetSrvInodeNum rc %d\n",
782 fattr
.cf_uniqueid
= iunique(sb
, ROOT_I
);
783 cifs_autodisable_serverino(cifs_sb
);
787 fattr
.cf_uniqueid
= iunique(sb
, ROOT_I
);
789 fattr
.cf_uniqueid
= CIFS_I(*inode
)->uniqueid
;
791 /* query for SFU type info if supported and needed */
792 if (fattr
.cf_cifsattrs
& ATTR_SYSTEM
&&
793 cifs_sb
->mnt_cifs_flags
& CIFS_MOUNT_UNX_EMUL
) {
794 tmprc
= cifs_sfu_type(&fattr
, full_path
, cifs_sb
, xid
);
796 cifs_dbg(FYI
, "cifs_sfu_type failed: %d\n", tmprc
);
799 #ifdef CONFIG_CIFS_ACL
800 /* fill in 0777 bits from ACL */
801 if (cifs_sb
->mnt_cifs_flags
& CIFS_MOUNT_CIFS_ACL
) {
802 rc
= cifs_acl_to_fattr(cifs_sb
, &fattr
, *inode
, full_path
, fid
);
804 cifs_dbg(FYI
, "%s: Getting ACL failed with error: %d\n",
809 #endif /* CONFIG_CIFS_ACL */
811 /* fill in remaining high mode bits e.g. SUID, VTX */
812 if (cifs_sb
->mnt_cifs_flags
& CIFS_MOUNT_UNX_EMUL
)
813 cifs_sfu_mode(&fattr
, full_path
, cifs_sb
, xid
);
815 /* check for Minshall+French symlinks */
816 if (cifs_sb
->mnt_cifs_flags
& CIFS_MOUNT_MF_SYMLINKS
) {
817 tmprc
= check_mf_symlink(xid
, tcon
, cifs_sb
, &fattr
,
820 cifs_dbg(FYI
, "check_mf_symlink: %d\n", tmprc
);
824 *inode
= cifs_iget(sb
, &fattr
);
828 cifs_fattr_to_inode(*inode
, &fattr
);
833 cifs_put_tlink(tlink
);
837 static const struct inode_operations cifs_ipc_inode_ops
= {
838 .lookup
= cifs_lookup
,
842 cifs_find_inode(struct inode
*inode
, void *opaque
)
844 struct cifs_fattr
*fattr
= (struct cifs_fattr
*) opaque
;
846 /* don't match inode with different uniqueid */
847 if (CIFS_I(inode
)->uniqueid
!= fattr
->cf_uniqueid
)
850 /* use createtime like an i_generation field */
851 if (CIFS_I(inode
)->createtime
!= fattr
->cf_createtime
)
854 /* don't match inode of different type */
855 if ((inode
->i_mode
& S_IFMT
) != (fattr
->cf_mode
& S_IFMT
))
858 /* if it's not a directory or has no dentries, then flag it */
859 if (S_ISDIR(inode
->i_mode
) && !hlist_empty(&inode
->i_dentry
))
860 fattr
->cf_flags
|= CIFS_FATTR_INO_COLLISION
;
866 cifs_init_inode(struct inode
*inode
, void *opaque
)
868 struct cifs_fattr
*fattr
= (struct cifs_fattr
*) opaque
;
870 CIFS_I(inode
)->uniqueid
= fattr
->cf_uniqueid
;
871 CIFS_I(inode
)->createtime
= fattr
->cf_createtime
;
876 * walk dentry list for an inode and report whether it has aliases that
877 * are hashed. We use this to determine if a directory inode can actually
881 inode_has_hashed_dentries(struct inode
*inode
)
883 struct dentry
*dentry
;
885 spin_lock(&inode
->i_lock
);
886 hlist_for_each_entry(dentry
, &inode
->i_dentry
, d_alias
) {
887 if (!d_unhashed(dentry
) || IS_ROOT(dentry
)) {
888 spin_unlock(&inode
->i_lock
);
892 spin_unlock(&inode
->i_lock
);
896 /* Given fattrs, get a corresponding inode */
898 cifs_iget(struct super_block
*sb
, struct cifs_fattr
*fattr
)
904 cifs_dbg(FYI
, "looking for uniqueid=%llu\n", fattr
->cf_uniqueid
);
906 /* hash down to 32-bits on 32-bit arch */
907 hash
= cifs_uniqueid_to_ino_t(fattr
->cf_uniqueid
);
909 inode
= iget5_locked(sb
, hash
, cifs_find_inode
, cifs_init_inode
, fattr
);
911 /* was there a potentially problematic inode collision? */
912 if (fattr
->cf_flags
& CIFS_FATTR_INO_COLLISION
) {
913 fattr
->cf_flags
&= ~CIFS_FATTR_INO_COLLISION
;
915 if (inode_has_hashed_dentries(inode
)) {
916 cifs_autodisable_serverino(CIFS_SB(sb
));
918 fattr
->cf_uniqueid
= iunique(sb
, ROOT_I
);
919 goto retry_iget5_locked
;
923 cifs_fattr_to_inode(inode
, fattr
);
924 if (sb
->s_flags
& MS_NOATIME
)
925 inode
->i_flags
|= S_NOATIME
| S_NOCMTIME
;
926 if (inode
->i_state
& I_NEW
) {
928 if (S_ISREG(inode
->i_mode
))
929 inode
->i_data
.backing_dev_info
= sb
->s_bdi
;
930 #ifdef CONFIG_CIFS_FSCACHE
931 /* initialize per-inode cache cookie pointer */
932 CIFS_I(inode
)->fscache
= NULL
;
934 unlock_new_inode(inode
);
941 /* gets root inode */
942 struct inode
*cifs_root_iget(struct super_block
*sb
)
945 struct cifs_sb_info
*cifs_sb
= CIFS_SB(sb
);
946 struct inode
*inode
= NULL
;
948 struct cifs_tcon
*tcon
= cifs_sb_master_tcon(cifs_sb
);
952 rc
= cifs_get_inode_info_unix(&inode
, "", sb
, xid
);
954 rc
= cifs_get_inode_info(&inode
, "", NULL
, sb
, xid
, NULL
);
961 #ifdef CONFIG_CIFS_FSCACHE
962 /* populate tcon->resource_id */
963 tcon
->resource_id
= CIFS_I(inode
)->uniqueid
;
966 if (rc
&& tcon
->ipc
) {
967 cifs_dbg(FYI
, "ipc connection - fake read inode\n");
968 spin_lock(&inode
->i_lock
);
969 inode
->i_mode
|= S_IFDIR
;
971 inode
->i_op
= &cifs_ipc_inode_ops
;
972 inode
->i_fop
= &simple_dir_operations
;
973 inode
->i_uid
= cifs_sb
->mnt_uid
;
974 inode
->i_gid
= cifs_sb
->mnt_gid
;
975 spin_unlock(&inode
->i_lock
);
982 /* can not call macro free_xid here since in a void func
983 * TODO: This is no longer true
990 cifs_set_file_info(struct inode
*inode
, struct iattr
*attrs
, unsigned int xid
,
991 char *full_path
, __u32 dosattr
)
993 bool set_time
= false;
994 struct cifs_sb_info
*cifs_sb
= CIFS_SB(inode
->i_sb
);
995 struct TCP_Server_Info
*server
;
996 FILE_BASIC_INFO info_buf
;
1001 server
= cifs_sb_master_tcon(cifs_sb
)->ses
->server
;
1002 if (!server
->ops
->set_file_info
)
1005 if (attrs
->ia_valid
& ATTR_ATIME
) {
1007 info_buf
.LastAccessTime
=
1008 cpu_to_le64(cifs_UnixTimeToNT(attrs
->ia_atime
));
1010 info_buf
.LastAccessTime
= 0;
1012 if (attrs
->ia_valid
& ATTR_MTIME
) {
1014 info_buf
.LastWriteTime
=
1015 cpu_to_le64(cifs_UnixTimeToNT(attrs
->ia_mtime
));
1017 info_buf
.LastWriteTime
= 0;
1020 * Samba throws this field away, but windows may actually use it.
1021 * Do not set ctime unless other time stamps are changed explicitly
1022 * (i.e. by utimes()) since we would then have a mix of client and
1025 if (set_time
&& (attrs
->ia_valid
& ATTR_CTIME
)) {
1026 cifs_dbg(FYI
, "CIFS - CTIME changed\n");
1027 info_buf
.ChangeTime
=
1028 cpu_to_le64(cifs_UnixTimeToNT(attrs
->ia_ctime
));
1030 info_buf
.ChangeTime
= 0;
1032 info_buf
.CreationTime
= 0; /* don't change */
1033 info_buf
.Attributes
= cpu_to_le32(dosattr
);
1035 return server
->ops
->set_file_info(inode
, full_path
, &info_buf
, xid
);
1039 * Open the given file (if it isn't already), set the DELETE_ON_CLOSE bit
1040 * and rename it to a random name that hopefully won't conflict with
1044 cifs_rename_pending_delete(const char *full_path
, struct dentry
*dentry
,
1045 const unsigned int xid
)
1049 struct cifs_fid fid
;
1050 struct cifs_open_parms oparms
;
1051 struct inode
*inode
= dentry
->d_inode
;
1052 struct cifsInodeInfo
*cifsInode
= CIFS_I(inode
);
1053 struct cifs_sb_info
*cifs_sb
= CIFS_SB(inode
->i_sb
);
1054 struct tcon_link
*tlink
;
1055 struct cifs_tcon
*tcon
;
1056 __u32 dosattr
, origattr
;
1057 FILE_BASIC_INFO
*info_buf
= NULL
;
1059 tlink
= cifs_sb_tlink(cifs_sb
);
1061 return PTR_ERR(tlink
);
1062 tcon
= tlink_tcon(tlink
);
1065 * We cannot rename the file if the server doesn't support
1066 * CAP_INFOLEVEL_PASSTHRU
1068 if (!(tcon
->ses
->capabilities
& CAP_INFOLEVEL_PASSTHRU
)) {
1074 oparms
.cifs_sb
= cifs_sb
;
1075 oparms
.desired_access
= DELETE
| FILE_WRITE_ATTRIBUTES
;
1076 oparms
.create_options
= CREATE_NOT_DIR
;
1077 oparms
.disposition
= FILE_OPEN
;
1078 oparms
.path
= full_path
;
1080 oparms
.reconnect
= false;
1082 rc
= CIFS_open(xid
, &oparms
, &oplock
, NULL
);
1086 origattr
= cifsInode
->cifsAttrs
;
1088 origattr
|= ATTR_NORMAL
;
1090 dosattr
= origattr
& ~ATTR_READONLY
;
1092 dosattr
|= ATTR_NORMAL
;
1093 dosattr
|= ATTR_HIDDEN
;
1095 /* set ATTR_HIDDEN and clear ATTR_READONLY, but only if needed */
1096 if (dosattr
!= origattr
) {
1097 info_buf
= kzalloc(sizeof(*info_buf
), GFP_KERNEL
);
1098 if (info_buf
== NULL
) {
1102 info_buf
->Attributes
= cpu_to_le32(dosattr
);
1103 rc
= CIFSSMBSetFileInfo(xid
, tcon
, info_buf
, fid
.netfid
,
1105 /* although we would like to mark the file hidden
1106 if that fails we will still try to rename it */
1108 cifsInode
->cifsAttrs
= dosattr
;
1110 dosattr
= origattr
; /* since not able to change them */
1113 /* rename the file */
1114 rc
= CIFSSMBRenameOpenFile(xid
, tcon
, fid
.netfid
, NULL
,
1116 cifs_sb
->mnt_cifs_flags
&
1117 CIFS_MOUNT_MAP_SPECIAL_CHR
);
1123 /* try to set DELETE_ON_CLOSE */
1124 if (!cifsInode
->delete_pending
) {
1125 rc
= CIFSSMBSetFileDisposition(xid
, tcon
, true, fid
.netfid
,
1128 * some samba versions return -ENOENT when we try to set the
1129 * file disposition here. Likely a samba bug, but work around
1130 * it for now. This means that some cifsXXX files may hang
1131 * around after they shouldn't.
1133 * BB: remove this hack after more servers have the fix
1141 cifsInode
->delete_pending
= true;
1145 CIFSSMBClose(xid
, tcon
, fid
.netfid
);
1148 cifs_put_tlink(tlink
);
1152 * reset everything back to the original state. Don't bother
1153 * dealing with errors here since we can't do anything about
1157 CIFSSMBRenameOpenFile(xid
, tcon
, fid
.netfid
, dentry
->d_name
.name
,
1158 cifs_sb
->local_nls
, cifs_sb
->mnt_cifs_flags
&
1159 CIFS_MOUNT_MAP_SPECIAL_CHR
);
1161 if (dosattr
!= origattr
) {
1162 info_buf
->Attributes
= cpu_to_le32(origattr
);
1163 if (!CIFSSMBSetFileInfo(xid
, tcon
, info_buf
, fid
.netfid
,
1165 cifsInode
->cifsAttrs
= origattr
;
1171 /* copied from fs/nfs/dir.c with small changes */
1173 cifs_drop_nlink(struct inode
*inode
)
1175 spin_lock(&inode
->i_lock
);
1176 if (inode
->i_nlink
> 0)
1178 spin_unlock(&inode
->i_lock
);
1182 * If dentry->d_inode is null (usually meaning the cached dentry
1183 * is a negative dentry) then we would attempt a standard SMB delete, but
1184 * if that fails we can not attempt the fall back mechanisms on EACCESS
1185 * but will return the EACCESS to the caller. Note that the VFS does not call
1186 * unlink on negative dentries currently.
1188 int cifs_unlink(struct inode
*dir
, struct dentry
*dentry
)
1192 char *full_path
= NULL
;
1193 struct inode
*inode
= dentry
->d_inode
;
1194 struct cifsInodeInfo
*cifs_inode
;
1195 struct super_block
*sb
= dir
->i_sb
;
1196 struct cifs_sb_info
*cifs_sb
= CIFS_SB(sb
);
1197 struct tcon_link
*tlink
;
1198 struct cifs_tcon
*tcon
;
1199 struct TCP_Server_Info
*server
;
1200 struct iattr
*attrs
= NULL
;
1201 __u32 dosattr
= 0, origattr
= 0;
1203 cifs_dbg(FYI
, "cifs_unlink, dir=0x%p, dentry=0x%p\n", dir
, dentry
);
1205 tlink
= cifs_sb_tlink(cifs_sb
);
1207 return PTR_ERR(tlink
);
1208 tcon
= tlink_tcon(tlink
);
1209 server
= tcon
->ses
->server
;
1213 /* Unlink can be called from rename so we can not take the
1214 * sb->s_vfs_rename_mutex here */
1215 full_path
= build_path_from_dentry(dentry
);
1216 if (full_path
== NULL
) {
1221 if (cap_unix(tcon
->ses
) && (CIFS_UNIX_POSIX_PATH_OPS_CAP
&
1222 le64_to_cpu(tcon
->fsUnixInfo
.Capability
))) {
1223 rc
= CIFSPOSIXDelFile(xid
, tcon
, full_path
,
1224 SMB_POSIX_UNLINK_FILE_TARGET
, cifs_sb
->local_nls
,
1225 cifs_sb
->mnt_cifs_flags
& CIFS_MOUNT_MAP_SPECIAL_CHR
);
1226 cifs_dbg(FYI
, "posix del rc %d\n", rc
);
1227 if ((rc
== 0) || (rc
== -ENOENT
))
1228 goto psx_del_no_retry
;
1232 if (!server
->ops
->unlink
) {
1234 goto psx_del_no_retry
;
1237 rc
= server
->ops
->unlink(xid
, tcon
, full_path
, cifs_sb
);
1242 cifs_drop_nlink(inode
);
1243 } else if (rc
== -ENOENT
) {
1245 } else if (rc
== -EBUSY
) {
1246 if (server
->ops
->rename_pending_delete
) {
1247 rc
= server
->ops
->rename_pending_delete(full_path
,
1250 cifs_drop_nlink(inode
);
1252 } else if ((rc
== -EACCES
) && (dosattr
== 0) && inode
) {
1253 attrs
= kzalloc(sizeof(*attrs
), GFP_KERNEL
);
1254 if (attrs
== NULL
) {
1259 /* try to reset dos attributes */
1260 cifs_inode
= CIFS_I(inode
);
1261 origattr
= cifs_inode
->cifsAttrs
;
1263 origattr
|= ATTR_NORMAL
;
1264 dosattr
= origattr
& ~ATTR_READONLY
;
1266 dosattr
|= ATTR_NORMAL
;
1267 dosattr
|= ATTR_HIDDEN
;
1269 rc
= cifs_set_file_info(inode
, attrs
, xid
, full_path
, dosattr
);
1273 goto retry_std_delete
;
1276 /* undo the setattr if we errored out and it's needed */
1277 if (rc
!= 0 && dosattr
!= 0)
1278 cifs_set_file_info(inode
, attrs
, xid
, full_path
, origattr
);
1282 cifs_inode
= CIFS_I(inode
);
1283 cifs_inode
->time
= 0; /* will force revalidate to get info
1285 inode
->i_ctime
= current_fs_time(sb
);
1287 dir
->i_ctime
= dir
->i_mtime
= current_fs_time(sb
);
1288 cifs_inode
= CIFS_I(dir
);
1289 CIFS_I(dir
)->time
= 0; /* force revalidate of dir as well */
1294 cifs_put_tlink(tlink
);
1299 cifs_mkdir_qinfo(struct inode
*parent
, struct dentry
*dentry
, umode_t mode
,
1300 const char *full_path
, struct cifs_sb_info
*cifs_sb
,
1301 struct cifs_tcon
*tcon
, const unsigned int xid
)
1304 struct inode
*inode
= NULL
;
1307 rc
= cifs_get_inode_info_unix(&inode
, full_path
, parent
->i_sb
,
1310 rc
= cifs_get_inode_info(&inode
, full_path
, NULL
, parent
->i_sb
,
1317 * setting nlink not necessary except in cases where we failed to get it
1318 * from the server or was set bogus. Also, since this is a brand new
1319 * inode, no need to grab the i_lock before setting the i_nlink.
1321 if (inode
->i_nlink
< 2)
1322 set_nlink(inode
, 2);
1323 mode
&= ~current_umask();
1324 /* must turn on setgid bit if parent dir has it */
1325 if (parent
->i_mode
& S_ISGID
)
1328 if (tcon
->unix_ext
) {
1329 struct cifs_unix_set_info_args args
= {
1331 .ctime
= NO_CHANGE_64
,
1332 .atime
= NO_CHANGE_64
,
1333 .mtime
= NO_CHANGE_64
,
1336 if (cifs_sb
->mnt_cifs_flags
& CIFS_MOUNT_SET_UID
) {
1337 args
.uid
= current_fsuid();
1338 if (parent
->i_mode
& S_ISGID
)
1339 args
.gid
= parent
->i_gid
;
1341 args
.gid
= current_fsgid();
1343 args
.uid
= INVALID_UID
; /* no change */
1344 args
.gid
= INVALID_GID
; /* no change */
1346 CIFSSMBUnixSetPathInfo(xid
, tcon
, full_path
, &args
,
1348 cifs_sb
->mnt_cifs_flags
&
1349 CIFS_MOUNT_MAP_SPECIAL_CHR
);
1351 struct TCP_Server_Info
*server
= tcon
->ses
->server
;
1352 if (!(cifs_sb
->mnt_cifs_flags
& CIFS_MOUNT_CIFS_ACL
) &&
1353 (mode
& S_IWUGO
) == 0 && server
->ops
->mkdir_setinfo
)
1354 server
->ops
->mkdir_setinfo(inode
, full_path
, cifs_sb
,
1356 if (cifs_sb
->mnt_cifs_flags
& CIFS_MOUNT_DYNPERM
)
1357 inode
->i_mode
= (mode
| S_IFDIR
);
1359 if (cifs_sb
->mnt_cifs_flags
& CIFS_MOUNT_SET_UID
) {
1360 inode
->i_uid
= current_fsuid();
1361 if (inode
->i_mode
& S_ISGID
)
1362 inode
->i_gid
= parent
->i_gid
;
1364 inode
->i_gid
= current_fsgid();
1367 d_instantiate(dentry
, inode
);
1372 cifs_posix_mkdir(struct inode
*inode
, struct dentry
*dentry
, umode_t mode
,
1373 const char *full_path
, struct cifs_sb_info
*cifs_sb
,
1374 struct cifs_tcon
*tcon
, const unsigned int xid
)
1378 FILE_UNIX_BASIC_INFO
*info
= NULL
;
1379 struct inode
*newinode
= NULL
;
1380 struct cifs_fattr fattr
;
1382 info
= kzalloc(sizeof(FILE_UNIX_BASIC_INFO
), GFP_KERNEL
);
1385 goto posix_mkdir_out
;
1388 mode
&= ~current_umask();
1389 rc
= CIFSPOSIXCreate(xid
, tcon
, SMB_O_DIRECTORY
| SMB_O_CREAT
, mode
,
1390 NULL
/* netfid */, info
, &oplock
, full_path
,
1391 cifs_sb
->local_nls
, cifs_sb
->mnt_cifs_flags
&
1392 CIFS_MOUNT_MAP_SPECIAL_CHR
);
1393 if (rc
== -EOPNOTSUPP
)
1394 goto posix_mkdir_out
;
1396 cifs_dbg(FYI
, "posix mkdir returned 0x%x\n", rc
);
1398 goto posix_mkdir_out
;
1401 if (info
->Type
== cpu_to_le32(-1))
1402 /* no return info, go query for it */
1403 goto posix_mkdir_get_info
;
1405 * BB check (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_SET_UID ) to see if
1406 * need to set uid/gid.
1409 cifs_unix_basic_to_fattr(&fattr
, info
, cifs_sb
);
1410 cifs_fill_uniqueid(inode
->i_sb
, &fattr
);
1411 newinode
= cifs_iget(inode
->i_sb
, &fattr
);
1413 goto posix_mkdir_get_info
;
1415 d_instantiate(dentry
, newinode
);
1417 #ifdef CONFIG_CIFS_DEBUG2
1418 cifs_dbg(FYI
, "instantiated dentry %p %s to inode %p\n",
1419 dentry
, dentry
->d_name
.name
, newinode
);
1421 if (newinode
->i_nlink
!= 2)
1422 cifs_dbg(FYI
, "unexpected number of links %d\n",
1429 posix_mkdir_get_info
:
1430 rc
= cifs_mkdir_qinfo(inode
, dentry
, mode
, full_path
, cifs_sb
, tcon
,
1432 goto posix_mkdir_out
;
1435 int cifs_mkdir(struct inode
*inode
, struct dentry
*direntry
, umode_t mode
)
1439 struct cifs_sb_info
*cifs_sb
;
1440 struct tcon_link
*tlink
;
1441 struct cifs_tcon
*tcon
;
1442 struct TCP_Server_Info
*server
;
1445 cifs_dbg(FYI
, "In cifs_mkdir, mode = 0x%hx inode = 0x%p\n",
1448 cifs_sb
= CIFS_SB(inode
->i_sb
);
1449 tlink
= cifs_sb_tlink(cifs_sb
);
1451 return PTR_ERR(tlink
);
1452 tcon
= tlink_tcon(tlink
);
1456 full_path
= build_path_from_dentry(direntry
);
1457 if (full_path
== NULL
) {
1462 if (cap_unix(tcon
->ses
) && (CIFS_UNIX_POSIX_PATH_OPS_CAP
&
1463 le64_to_cpu(tcon
->fsUnixInfo
.Capability
))) {
1464 rc
= cifs_posix_mkdir(inode
, direntry
, mode
, full_path
, cifs_sb
,
1466 if (rc
!= -EOPNOTSUPP
)
1470 server
= tcon
->ses
->server
;
1472 if (!server
->ops
->mkdir
) {
1477 /* BB add setting the equivalent of mode via CreateX w/ACLs */
1478 rc
= server
->ops
->mkdir(xid
, tcon
, full_path
, cifs_sb
);
1480 cifs_dbg(FYI
, "cifs_mkdir returned 0x%x\n", rc
);
1485 rc
= cifs_mkdir_qinfo(inode
, direntry
, mode
, full_path
, cifs_sb
, tcon
,
1489 * Force revalidate to get parent dir info when needed since cached
1490 * attributes are invalid now.
1492 CIFS_I(inode
)->time
= 0;
1495 cifs_put_tlink(tlink
);
1499 int cifs_rmdir(struct inode
*inode
, struct dentry
*direntry
)
1503 struct cifs_sb_info
*cifs_sb
;
1504 struct tcon_link
*tlink
;
1505 struct cifs_tcon
*tcon
;
1506 struct TCP_Server_Info
*server
;
1507 char *full_path
= NULL
;
1508 struct cifsInodeInfo
*cifsInode
;
1510 cifs_dbg(FYI
, "cifs_rmdir, inode = 0x%p\n", inode
);
1514 full_path
= build_path_from_dentry(direntry
);
1515 if (full_path
== NULL
) {
1520 cifs_sb
= CIFS_SB(inode
->i_sb
);
1521 tlink
= cifs_sb_tlink(cifs_sb
);
1522 if (IS_ERR(tlink
)) {
1523 rc
= PTR_ERR(tlink
);
1526 tcon
= tlink_tcon(tlink
);
1527 server
= tcon
->ses
->server
;
1529 if (!server
->ops
->rmdir
) {
1531 cifs_put_tlink(tlink
);
1535 rc
= server
->ops
->rmdir(xid
, tcon
, full_path
, cifs_sb
);
1536 cifs_put_tlink(tlink
);
1539 spin_lock(&direntry
->d_inode
->i_lock
);
1540 i_size_write(direntry
->d_inode
, 0);
1541 clear_nlink(direntry
->d_inode
);
1542 spin_unlock(&direntry
->d_inode
->i_lock
);
1545 cifsInode
= CIFS_I(direntry
->d_inode
);
1546 /* force revalidate to go get info when needed */
1547 cifsInode
->time
= 0;
1549 cifsInode
= CIFS_I(inode
);
1551 * Force revalidate to get parent dir info when needed since cached
1552 * attributes are invalid now.
1554 cifsInode
->time
= 0;
1556 direntry
->d_inode
->i_ctime
= inode
->i_ctime
= inode
->i_mtime
=
1557 current_fs_time(inode
->i_sb
);
1566 cifs_do_rename(const unsigned int xid
, struct dentry
*from_dentry
,
1567 const char *from_path
, struct dentry
*to_dentry
,
1568 const char *to_path
)
1570 struct cifs_sb_info
*cifs_sb
= CIFS_SB(from_dentry
->d_sb
);
1571 struct tcon_link
*tlink
;
1572 struct cifs_tcon
*tcon
;
1573 struct TCP_Server_Info
*server
;
1574 struct cifs_fid fid
;
1575 struct cifs_open_parms oparms
;
1578 tlink
= cifs_sb_tlink(cifs_sb
);
1580 return PTR_ERR(tlink
);
1581 tcon
= tlink_tcon(tlink
);
1582 server
= tcon
->ses
->server
;
1584 if (!server
->ops
->rename
)
1587 /* try path-based rename first */
1588 rc
= server
->ops
->rename(xid
, tcon
, from_path
, to_path
, cifs_sb
);
1591 * Don't bother with rename by filehandle unless file is busy and
1592 * source. Note that cross directory moves do not work with
1593 * rename by filehandle to various Windows servers.
1595 if (rc
== 0 || rc
!= -EBUSY
)
1596 goto do_rename_exit
;
1598 /* open-file renames don't work across directories */
1599 if (to_dentry
->d_parent
!= from_dentry
->d_parent
)
1600 goto do_rename_exit
;
1603 oparms
.cifs_sb
= cifs_sb
;
1604 /* open the file to be renamed -- we need DELETE perms */
1605 oparms
.desired_access
= DELETE
;
1606 oparms
.create_options
= CREATE_NOT_DIR
;
1607 oparms
.disposition
= FILE_OPEN
;
1608 oparms
.path
= from_path
;
1610 oparms
.reconnect
= false;
1612 rc
= CIFS_open(xid
, &oparms
, &oplock
, NULL
);
1614 rc
= CIFSSMBRenameOpenFile(xid
, tcon
, fid
.netfid
,
1615 (const char *) to_dentry
->d_name
.name
,
1616 cifs_sb
->local_nls
, cifs_sb
->mnt_cifs_flags
&
1617 CIFS_MOUNT_MAP_SPECIAL_CHR
);
1618 CIFSSMBClose(xid
, tcon
, fid
.netfid
);
1621 cifs_put_tlink(tlink
);
1626 cifs_rename(struct inode
*source_dir
, struct dentry
*source_dentry
,
1627 struct inode
*target_dir
, struct dentry
*target_dentry
)
1629 char *from_name
= NULL
;
1630 char *to_name
= NULL
;
1631 struct cifs_sb_info
*cifs_sb
;
1632 struct tcon_link
*tlink
;
1633 struct cifs_tcon
*tcon
;
1634 FILE_UNIX_BASIC_INFO
*info_buf_source
= NULL
;
1635 FILE_UNIX_BASIC_INFO
*info_buf_target
;
1639 cifs_sb
= CIFS_SB(source_dir
->i_sb
);
1640 tlink
= cifs_sb_tlink(cifs_sb
);
1642 return PTR_ERR(tlink
);
1643 tcon
= tlink_tcon(tlink
);
1648 * we already have the rename sem so we do not need to
1649 * grab it again here to protect the path integrity
1651 from_name
= build_path_from_dentry(source_dentry
);
1652 if (from_name
== NULL
) {
1654 goto cifs_rename_exit
;
1657 to_name
= build_path_from_dentry(target_dentry
);
1658 if (to_name
== NULL
) {
1660 goto cifs_rename_exit
;
1663 rc
= cifs_do_rename(xid
, source_dentry
, from_name
, target_dentry
,
1666 if (rc
== -EEXIST
&& tcon
->unix_ext
) {
1668 * Are src and dst hardlinks of same inode? We can only tell
1669 * with unix extensions enabled.
1672 kmalloc(2 * sizeof(FILE_UNIX_BASIC_INFO
),
1674 if (info_buf_source
== NULL
) {
1676 goto cifs_rename_exit
;
1679 info_buf_target
= info_buf_source
+ 1;
1680 tmprc
= CIFSSMBUnixQPathInfo(xid
, tcon
, from_name
,
1683 cifs_sb
->mnt_cifs_flags
&
1684 CIFS_MOUNT_MAP_SPECIAL_CHR
);
1688 tmprc
= CIFSSMBUnixQPathInfo(xid
, tcon
, to_name
,
1691 cifs_sb
->mnt_cifs_flags
&
1692 CIFS_MOUNT_MAP_SPECIAL_CHR
);
1694 if (tmprc
== 0 && (info_buf_source
->UniqueId
==
1695 info_buf_target
->UniqueId
)) {
1696 /* same file, POSIX says that this is a noop */
1698 goto cifs_rename_exit
;
1702 * else ... BB we could add the same check for Windows by
1703 * checking the UniqueId via FILE_INTERNAL_INFO
1707 /* Try unlinking the target dentry if it's not negative */
1708 if (target_dentry
->d_inode
&& (rc
== -EACCES
|| rc
== -EEXIST
)) {
1709 tmprc
= cifs_unlink(target_dir
, target_dentry
);
1711 goto cifs_rename_exit
;
1712 rc
= cifs_do_rename(xid
, source_dentry
, from_name
,
1713 target_dentry
, to_name
);
1717 kfree(info_buf_source
);
1721 cifs_put_tlink(tlink
);
1726 cifs_inode_needs_reval(struct inode
*inode
)
1728 struct cifsInodeInfo
*cifs_i
= CIFS_I(inode
);
1729 struct cifs_sb_info
*cifs_sb
= CIFS_SB(inode
->i_sb
);
1731 if (CIFS_CACHE_READ(cifs_i
))
1734 if (!lookupCacheEnabled
)
1737 if (cifs_i
->time
== 0)
1740 if (!cifs_sb
->actimeo
)
1743 if (!time_in_range(jiffies
, cifs_i
->time
,
1744 cifs_i
->time
+ cifs_sb
->actimeo
))
1747 /* hardlinked files w/ noserverino get "special" treatment */
1748 if (!(cifs_sb
->mnt_cifs_flags
& CIFS_MOUNT_SERVER_INUM
) &&
1749 S_ISREG(inode
->i_mode
) && inode
->i_nlink
!= 1)
1756 * Zap the cache. Called when invalid_mapping flag is set.
1759 cifs_invalidate_mapping(struct inode
*inode
)
1762 struct cifsInodeInfo
*cifs_i
= CIFS_I(inode
);
1764 cifs_i
->invalid_mapping
= false;
1766 if (inode
->i_mapping
&& inode
->i_mapping
->nrpages
!= 0) {
1767 rc
= invalidate_inode_pages2(inode
->i_mapping
);
1769 cifs_dbg(VFS
, "%s: could not invalidate inode %p\n",
1771 cifs_i
->invalid_mapping
= true;
1775 cifs_fscache_reset_inode_cookie(inode
);
1779 int cifs_revalidate_file_attr(struct file
*filp
)
1782 struct inode
*inode
= file_inode(filp
);
1783 struct cifsFileInfo
*cfile
= (struct cifsFileInfo
*) filp
->private_data
;
1785 if (!cifs_inode_needs_reval(inode
))
1788 if (tlink_tcon(cfile
->tlink
)->unix_ext
)
1789 rc
= cifs_get_file_info_unix(filp
);
1791 rc
= cifs_get_file_info(filp
);
1796 int cifs_revalidate_dentry_attr(struct dentry
*dentry
)
1800 struct inode
*inode
= dentry
->d_inode
;
1801 struct super_block
*sb
= dentry
->d_sb
;
1802 char *full_path
= NULL
;
1807 if (!cifs_inode_needs_reval(inode
))
1812 /* can not safely grab the rename sem here if rename calls revalidate
1813 since that would deadlock */
1814 full_path
= build_path_from_dentry(dentry
);
1815 if (full_path
== NULL
) {
1820 cifs_dbg(FYI
, "Update attributes: %s inode 0x%p count %d dentry: 0x%p d_time %ld jiffies %ld\n",
1821 full_path
, inode
, inode
->i_count
.counter
,
1822 dentry
, dentry
->d_time
, jiffies
);
1824 if (cifs_sb_master_tcon(CIFS_SB(sb
))->unix_ext
)
1825 rc
= cifs_get_inode_info_unix(&inode
, full_path
, sb
, xid
);
1827 rc
= cifs_get_inode_info(&inode
, full_path
, NULL
, sb
,
1836 int cifs_revalidate_file(struct file
*filp
)
1839 struct inode
*inode
= file_inode(filp
);
1841 rc
= cifs_revalidate_file_attr(filp
);
1845 if (CIFS_I(inode
)->invalid_mapping
)
1846 rc
= cifs_invalidate_mapping(inode
);
1850 /* revalidate a dentry's inode attributes */
1851 int cifs_revalidate_dentry(struct dentry
*dentry
)
1854 struct inode
*inode
= dentry
->d_inode
;
1856 rc
= cifs_revalidate_dentry_attr(dentry
);
1860 if (CIFS_I(inode
)->invalid_mapping
)
1861 rc
= cifs_invalidate_mapping(inode
);
1865 int cifs_getattr(struct vfsmount
*mnt
, struct dentry
*dentry
,
1868 struct cifs_sb_info
*cifs_sb
= CIFS_SB(dentry
->d_sb
);
1869 struct cifs_tcon
*tcon
= cifs_sb_master_tcon(cifs_sb
);
1870 struct inode
*inode
= dentry
->d_inode
;
1874 * We need to be sure that all dirty pages are written and the server
1875 * has actual ctime, mtime and file length.
1877 if (!CIFS_CACHE_READ(CIFS_I(inode
)) && inode
->i_mapping
&&
1878 inode
->i_mapping
->nrpages
!= 0) {
1879 rc
= filemap_fdatawait(inode
->i_mapping
);
1881 mapping_set_error(inode
->i_mapping
, rc
);
1886 rc
= cifs_revalidate_dentry_attr(dentry
);
1890 generic_fillattr(inode
, stat
);
1891 stat
->blksize
= CIFS_MAX_MSGSIZE
;
1892 stat
->ino
= CIFS_I(inode
)->uniqueid
;
1895 * If on a multiuser mount without unix extensions or cifsacl being
1896 * enabled, and the admin hasn't overridden them, set the ownership
1897 * to the fsuid/fsgid of the current process.
1899 if ((cifs_sb
->mnt_cifs_flags
& CIFS_MOUNT_MULTIUSER
) &&
1900 !(cifs_sb
->mnt_cifs_flags
& CIFS_MOUNT_CIFS_ACL
) &&
1902 if (!(cifs_sb
->mnt_cifs_flags
& CIFS_MOUNT_OVERR_UID
))
1903 stat
->uid
= current_fsuid();
1904 if (!(cifs_sb
->mnt_cifs_flags
& CIFS_MOUNT_OVERR_GID
))
1905 stat
->gid
= current_fsgid();
1910 static int cifs_truncate_page(struct address_space
*mapping
, loff_t from
)
1912 pgoff_t index
= from
>> PAGE_CACHE_SHIFT
;
1913 unsigned offset
= from
& (PAGE_CACHE_SIZE
- 1);
1917 page
= grab_cache_page(mapping
, index
);
1921 zero_user_segment(page
, offset
, PAGE_CACHE_SIZE
);
1923 page_cache_release(page
);
1927 static void cifs_setsize(struct inode
*inode
, loff_t offset
)
1929 spin_lock(&inode
->i_lock
);
1930 i_size_write(inode
, offset
);
1931 spin_unlock(&inode
->i_lock
);
1933 truncate_pagecache(inode
, offset
);
1937 cifs_set_file_size(struct inode
*inode
, struct iattr
*attrs
,
1938 unsigned int xid
, char *full_path
)
1941 struct cifsFileInfo
*open_file
;
1942 struct cifsInodeInfo
*cifsInode
= CIFS_I(inode
);
1943 struct cifs_sb_info
*cifs_sb
= CIFS_SB(inode
->i_sb
);
1944 struct tcon_link
*tlink
= NULL
;
1945 struct cifs_tcon
*tcon
= NULL
;
1946 struct TCP_Server_Info
*server
;
1947 struct cifs_io_parms io_parms
;
1950 * To avoid spurious oplock breaks from server, in the case of
1951 * inodes that we already have open, avoid doing path based
1952 * setting of file size if we can do it by handle.
1953 * This keeps our caching token (oplock) and avoids timeouts
1954 * when the local oplock break takes longer to flush
1955 * writebehind data than the SMB timeout for the SetPathInfo
1956 * request would allow
1958 open_file
= find_writable_file(cifsInode
, true);
1960 tcon
= tlink_tcon(open_file
->tlink
);
1961 server
= tcon
->ses
->server
;
1962 if (server
->ops
->set_file_size
)
1963 rc
= server
->ops
->set_file_size(xid
, tcon
, open_file
,
1964 attrs
->ia_size
, false);
1967 cifsFileInfo_put(open_file
);
1968 cifs_dbg(FYI
, "SetFSize for attrs rc = %d\n", rc
);
1969 if ((rc
== -EINVAL
) || (rc
== -EOPNOTSUPP
)) {
1970 unsigned int bytes_written
;
1972 io_parms
.netfid
= open_file
->fid
.netfid
;
1973 io_parms
.pid
= open_file
->pid
;
1974 io_parms
.tcon
= tcon
;
1975 io_parms
.offset
= 0;
1976 io_parms
.length
= attrs
->ia_size
;
1977 rc
= CIFSSMBWrite(xid
, &io_parms
, &bytes_written
,
1979 cifs_dbg(FYI
, "Wrt seteof rc %d\n", rc
);
1988 tlink
= cifs_sb_tlink(cifs_sb
);
1990 return PTR_ERR(tlink
);
1991 tcon
= tlink_tcon(tlink
);
1992 server
= tcon
->ses
->server
;
1996 * Set file size by pathname rather than by handle either because no
1997 * valid, writeable file handle for it was found or because there was
1998 * an error setting it by handle.
2000 if (server
->ops
->set_path_size
)
2001 rc
= server
->ops
->set_path_size(xid
, tcon
, full_path
,
2002 attrs
->ia_size
, cifs_sb
, false);
2005 cifs_dbg(FYI
, "SetEOF by path (setattrs) rc = %d\n", rc
);
2006 if ((rc
== -EINVAL
) || (rc
== -EOPNOTSUPP
)) {
2010 rc
= SMBLegacyOpen(xid
, tcon
, full_path
, FILE_OPEN
,
2011 GENERIC_WRITE
, CREATE_NOT_DIR
, &netfid
,
2012 &oplock
, NULL
, cifs_sb
->local_nls
,
2013 cifs_sb
->mnt_cifs_flags
&
2014 CIFS_MOUNT_MAP_SPECIAL_CHR
);
2016 unsigned int bytes_written
;
2018 io_parms
.netfid
= netfid
;
2019 io_parms
.pid
= current
->tgid
;
2020 io_parms
.tcon
= tcon
;
2021 io_parms
.offset
= 0;
2022 io_parms
.length
= attrs
->ia_size
;
2023 rc
= CIFSSMBWrite(xid
, &io_parms
, &bytes_written
, NULL
,
2025 cifs_dbg(FYI
, "wrt seteof rc %d\n", rc
);
2026 CIFSSMBClose(xid
, tcon
, netfid
);
2030 cifs_put_tlink(tlink
);
2034 cifsInode
->server_eof
= attrs
->ia_size
;
2035 cifs_setsize(inode
, attrs
->ia_size
);
2036 cifs_truncate_page(inode
->i_mapping
, inode
->i_size
);
2043 cifs_setattr_unix(struct dentry
*direntry
, struct iattr
*attrs
)
2047 char *full_path
= NULL
;
2048 struct inode
*inode
= direntry
->d_inode
;
2049 struct cifsInodeInfo
*cifsInode
= CIFS_I(inode
);
2050 struct cifs_sb_info
*cifs_sb
= CIFS_SB(inode
->i_sb
);
2051 struct tcon_link
*tlink
;
2052 struct cifs_tcon
*pTcon
;
2053 struct cifs_unix_set_info_args
*args
= NULL
;
2054 struct cifsFileInfo
*open_file
;
2056 cifs_dbg(FYI
, "setattr_unix on file %s attrs->ia_valid=0x%x\n",
2057 direntry
->d_name
.name
, attrs
->ia_valid
);
2061 if (cifs_sb
->mnt_cifs_flags
& CIFS_MOUNT_NO_PERM
)
2062 attrs
->ia_valid
|= ATTR_FORCE
;
2064 rc
= inode_change_ok(inode
, attrs
);
2068 full_path
= build_path_from_dentry(direntry
);
2069 if (full_path
== NULL
) {
2075 * Attempt to flush data before changing attributes. We need to do
2076 * this for ATTR_SIZE and ATTR_MTIME for sure, and if we change the
2077 * ownership or mode then we may also need to do this. Here, we take
2078 * the safe way out and just do the flush on all setattr requests. If
2079 * the flush returns error, store it to report later and continue.
2081 * BB: This should be smarter. Why bother flushing pages that
2082 * will be truncated anyway? Also, should we error out here if
2083 * the flush returns error?
2085 rc
= filemap_write_and_wait(inode
->i_mapping
);
2086 mapping_set_error(inode
->i_mapping
, rc
);
2089 if (attrs
->ia_valid
& ATTR_SIZE
) {
2090 rc
= cifs_set_file_size(inode
, attrs
, xid
, full_path
);
2095 /* skip mode change if it's just for clearing setuid/setgid */
2096 if (attrs
->ia_valid
& (ATTR_KILL_SUID
|ATTR_KILL_SGID
))
2097 attrs
->ia_valid
&= ~ATTR_MODE
;
2099 args
= kmalloc(sizeof(*args
), GFP_KERNEL
);
2105 /* set up the struct */
2106 if (attrs
->ia_valid
& ATTR_MODE
)
2107 args
->mode
= attrs
->ia_mode
;
2109 args
->mode
= NO_CHANGE_64
;
2111 if (attrs
->ia_valid
& ATTR_UID
)
2112 args
->uid
= attrs
->ia_uid
;
2114 args
->uid
= INVALID_UID
; /* no change */
2116 if (attrs
->ia_valid
& ATTR_GID
)
2117 args
->gid
= attrs
->ia_gid
;
2119 args
->gid
= INVALID_GID
; /* no change */
2121 if (attrs
->ia_valid
& ATTR_ATIME
)
2122 args
->atime
= cifs_UnixTimeToNT(attrs
->ia_atime
);
2124 args
->atime
= NO_CHANGE_64
;
2126 if (attrs
->ia_valid
& ATTR_MTIME
)
2127 args
->mtime
= cifs_UnixTimeToNT(attrs
->ia_mtime
);
2129 args
->mtime
= NO_CHANGE_64
;
2131 if (attrs
->ia_valid
& ATTR_CTIME
)
2132 args
->ctime
= cifs_UnixTimeToNT(attrs
->ia_ctime
);
2134 args
->ctime
= NO_CHANGE_64
;
2137 open_file
= find_writable_file(cifsInode
, true);
2139 u16 nfid
= open_file
->fid
.netfid
;
2140 u32 npid
= open_file
->pid
;
2141 pTcon
= tlink_tcon(open_file
->tlink
);
2142 rc
= CIFSSMBUnixSetFileInfo(xid
, pTcon
, args
, nfid
, npid
);
2143 cifsFileInfo_put(open_file
);
2145 tlink
= cifs_sb_tlink(cifs_sb
);
2146 if (IS_ERR(tlink
)) {
2147 rc
= PTR_ERR(tlink
);
2150 pTcon
= tlink_tcon(tlink
);
2151 rc
= CIFSSMBUnixSetPathInfo(xid
, pTcon
, full_path
, args
,
2153 cifs_sb
->mnt_cifs_flags
&
2154 CIFS_MOUNT_MAP_SPECIAL_CHR
);
2155 cifs_put_tlink(tlink
);
2161 if ((attrs
->ia_valid
& ATTR_SIZE
) &&
2162 attrs
->ia_size
!= i_size_read(inode
))
2163 truncate_setsize(inode
, attrs
->ia_size
);
2165 setattr_copy(inode
, attrs
);
2166 mark_inode_dirty(inode
);
2168 /* force revalidate when any of these times are set since some
2169 of the fs types (eg ext3, fat) do not have fine enough
2170 time granularity to match protocol, and we do not have a
2171 a way (yet) to query the server fs's time granularity (and
2172 whether it rounds times down).
2174 if (attrs
->ia_valid
& (ATTR_MTIME
| ATTR_CTIME
))
2175 cifsInode
->time
= 0;
2184 cifs_setattr_nounix(struct dentry
*direntry
, struct iattr
*attrs
)
2187 kuid_t uid
= INVALID_UID
;
2188 kgid_t gid
= INVALID_GID
;
2189 struct inode
*inode
= direntry
->d_inode
;
2190 struct cifs_sb_info
*cifs_sb
= CIFS_SB(inode
->i_sb
);
2191 struct cifsInodeInfo
*cifsInode
= CIFS_I(inode
);
2192 char *full_path
= NULL
;
2195 __u64 mode
= NO_CHANGE_64
;
2199 cifs_dbg(FYI
, "setattr on file %s attrs->iavalid 0x%x\n",
2200 direntry
->d_name
.name
, attrs
->ia_valid
);
2202 if (cifs_sb
->mnt_cifs_flags
& CIFS_MOUNT_NO_PERM
)
2203 attrs
->ia_valid
|= ATTR_FORCE
;
2205 rc
= inode_change_ok(inode
, attrs
);
2211 full_path
= build_path_from_dentry(direntry
);
2212 if (full_path
== NULL
) {
2219 * Attempt to flush data before changing attributes. We need to do
2220 * this for ATTR_SIZE and ATTR_MTIME for sure, and if we change the
2221 * ownership or mode then we may also need to do this. Here, we take
2222 * the safe way out and just do the flush on all setattr requests. If
2223 * the flush returns error, store it to report later and continue.
2225 * BB: This should be smarter. Why bother flushing pages that
2226 * will be truncated anyway? Also, should we error out here if
2227 * the flush returns error?
2229 rc
= filemap_write_and_wait(inode
->i_mapping
);
2230 mapping_set_error(inode
->i_mapping
, rc
);
2233 if (attrs
->ia_valid
& ATTR_SIZE
) {
2234 rc
= cifs_set_file_size(inode
, attrs
, xid
, full_path
);
2236 goto cifs_setattr_exit
;
2239 if (attrs
->ia_valid
& ATTR_UID
)
2240 uid
= attrs
->ia_uid
;
2242 if (attrs
->ia_valid
& ATTR_GID
)
2243 gid
= attrs
->ia_gid
;
2245 #ifdef CONFIG_CIFS_ACL
2246 if (cifs_sb
->mnt_cifs_flags
& CIFS_MOUNT_CIFS_ACL
) {
2247 if (uid_valid(uid
) || gid_valid(gid
)) {
2248 rc
= id_mode_to_cifs_acl(inode
, full_path
, NO_CHANGE_64
,
2251 cifs_dbg(FYI
, "%s: Setting id failed with error: %d\n",
2253 goto cifs_setattr_exit
;
2257 #endif /* CONFIG_CIFS_ACL */
2258 if (!(cifs_sb
->mnt_cifs_flags
& CIFS_MOUNT_SET_UID
))
2259 attrs
->ia_valid
&= ~(ATTR_UID
| ATTR_GID
);
2261 /* skip mode change if it's just for clearing setuid/setgid */
2262 if (attrs
->ia_valid
& (ATTR_KILL_SUID
|ATTR_KILL_SGID
))
2263 attrs
->ia_valid
&= ~ATTR_MODE
;
2265 if (attrs
->ia_valid
& ATTR_MODE
) {
2266 mode
= attrs
->ia_mode
;
2268 #ifdef CONFIG_CIFS_ACL
2269 if (cifs_sb
->mnt_cifs_flags
& CIFS_MOUNT_CIFS_ACL
) {
2270 rc
= id_mode_to_cifs_acl(inode
, full_path
, mode
,
2271 INVALID_UID
, INVALID_GID
);
2273 cifs_dbg(FYI
, "%s: Setting ACL failed with error: %d\n",
2275 goto cifs_setattr_exit
;
2278 #endif /* CONFIG_CIFS_ACL */
2279 if (((mode
& S_IWUGO
) == 0) &&
2280 (cifsInode
->cifsAttrs
& ATTR_READONLY
) == 0) {
2282 dosattr
= cifsInode
->cifsAttrs
| ATTR_READONLY
;
2284 /* fix up mode if we're not using dynperm */
2285 if ((cifs_sb
->mnt_cifs_flags
& CIFS_MOUNT_DYNPERM
) == 0)
2286 attrs
->ia_mode
= inode
->i_mode
& ~S_IWUGO
;
2287 } else if ((mode
& S_IWUGO
) &&
2288 (cifsInode
->cifsAttrs
& ATTR_READONLY
)) {
2290 dosattr
= cifsInode
->cifsAttrs
& ~ATTR_READONLY
;
2291 /* Attributes of 0 are ignored */
2293 dosattr
|= ATTR_NORMAL
;
2295 /* reset local inode permissions to normal */
2296 if (!(cifs_sb
->mnt_cifs_flags
& CIFS_MOUNT_DYNPERM
)) {
2297 attrs
->ia_mode
&= ~(S_IALLUGO
);
2298 if (S_ISDIR(inode
->i_mode
))
2300 cifs_sb
->mnt_dir_mode
;
2303 cifs_sb
->mnt_file_mode
;
2305 } else if (!(cifs_sb
->mnt_cifs_flags
& CIFS_MOUNT_DYNPERM
)) {
2306 /* ignore mode change - ATTR_READONLY hasn't changed */
2307 attrs
->ia_valid
&= ~ATTR_MODE
;
2311 if (attrs
->ia_valid
& (ATTR_MTIME
|ATTR_ATIME
|ATTR_CTIME
) ||
2312 ((attrs
->ia_valid
& ATTR_MODE
) && dosattr
)) {
2313 rc
= cifs_set_file_info(inode
, attrs
, xid
, full_path
, dosattr
);
2314 /* BB: check for rc = -EOPNOTSUPP and switch to legacy mode */
2316 /* Even if error on time set, no sense failing the call if
2317 the server would set the time to a reasonable value anyway,
2318 and this check ensures that we are not being called from
2319 sys_utimes in which case we ought to fail the call back to
2320 the user when the server rejects the call */
2321 if ((rc
) && (attrs
->ia_valid
&
2322 (ATTR_MODE
| ATTR_GID
| ATTR_UID
| ATTR_SIZE
)))
2326 /* do not need local check to inode_check_ok since the server does
2329 goto cifs_setattr_exit
;
2331 if ((attrs
->ia_valid
& ATTR_SIZE
) &&
2332 attrs
->ia_size
!= i_size_read(inode
))
2333 truncate_setsize(inode
, attrs
->ia_size
);
2335 setattr_copy(inode
, attrs
);
2336 mark_inode_dirty(inode
);
2345 cifs_setattr(struct dentry
*direntry
, struct iattr
*attrs
)
2347 struct inode
*inode
= direntry
->d_inode
;
2348 struct cifs_sb_info
*cifs_sb
= CIFS_SB(inode
->i_sb
);
2349 struct cifs_tcon
*pTcon
= cifs_sb_master_tcon(cifs_sb
);
2351 if (pTcon
->unix_ext
)
2352 return cifs_setattr_unix(direntry
, attrs
);
2354 return cifs_setattr_nounix(direntry
, attrs
);
2356 /* BB: add cifs_setattr_legacy for really old servers */
2360 void cifs_delete_inode(struct inode
*inode
)
2362 cifs_dbg(FYI
, "In cifs_delete_inode, inode = 0x%p\n", inode
);
2363 /* may have to add back in if and when safe distributed caching of
2364 directories added e.g. via FindNotify */