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;
123 /* populate an inode with info from a cifs_fattr struct */
125 cifs_fattr_to_inode(struct inode
*inode
, struct cifs_fattr
*fattr
)
127 struct cifsInodeInfo
*cifs_i
= CIFS_I(inode
);
128 struct cifs_sb_info
*cifs_sb
= CIFS_SB(inode
->i_sb
);
130 cifs_revalidate_cache(inode
, fattr
);
132 spin_lock(&inode
->i_lock
);
133 inode
->i_atime
= fattr
->cf_atime
;
134 inode
->i_mtime
= fattr
->cf_mtime
;
135 inode
->i_ctime
= fattr
->cf_ctime
;
136 inode
->i_rdev
= fattr
->cf_rdev
;
137 set_nlink(inode
, fattr
->cf_nlink
);
138 inode
->i_uid
= fattr
->cf_uid
;
139 inode
->i_gid
= fattr
->cf_gid
;
141 /* if dynperm is set, don't clobber existing mode */
142 if (inode
->i_state
& I_NEW
||
143 !(cifs_sb
->mnt_cifs_flags
& CIFS_MOUNT_DYNPERM
))
144 inode
->i_mode
= fattr
->cf_mode
;
146 cifs_i
->cifsAttrs
= fattr
->cf_cifsattrs
;
148 if (fattr
->cf_flags
& CIFS_FATTR_NEED_REVAL
)
151 cifs_i
->time
= jiffies
;
153 cifs_i
->delete_pending
= fattr
->cf_flags
& CIFS_FATTR_DELETE_PENDING
;
155 cifs_i
->server_eof
= fattr
->cf_eof
;
157 * Can't safely change the file size here if the client is writing to
158 * it due to potential races.
160 if (is_size_safe_to_change(cifs_i
, fattr
->cf_eof
)) {
161 i_size_write(inode
, fattr
->cf_eof
);
164 * i_blocks is not related to (i_size / i_blksize),
165 * but instead 512 byte (2**9) size is required for
166 * calculating num blocks.
168 inode
->i_blocks
= (512 - 1 + fattr
->cf_bytes
) >> 9;
170 spin_unlock(&inode
->i_lock
);
172 if (fattr
->cf_flags
& CIFS_FATTR_DFS_REFERRAL
)
173 inode
->i_flags
|= S_AUTOMOUNT
;
174 if (inode
->i_state
& I_NEW
)
179 cifs_fill_uniqueid(struct super_block
*sb
, struct cifs_fattr
*fattr
)
181 struct cifs_sb_info
*cifs_sb
= CIFS_SB(sb
);
183 if (cifs_sb
->mnt_cifs_flags
& CIFS_MOUNT_SERVER_INUM
)
186 fattr
->cf_uniqueid
= iunique(sb
, ROOT_I
);
189 /* Fill a cifs_fattr struct with info from FILE_UNIX_BASIC_INFO. */
191 cifs_unix_basic_to_fattr(struct cifs_fattr
*fattr
, FILE_UNIX_BASIC_INFO
*info
,
192 struct cifs_sb_info
*cifs_sb
)
194 memset(fattr
, 0, sizeof(*fattr
));
195 fattr
->cf_uniqueid
= le64_to_cpu(info
->UniqueId
);
196 fattr
->cf_bytes
= le64_to_cpu(info
->NumOfBytes
);
197 fattr
->cf_eof
= le64_to_cpu(info
->EndOfFile
);
199 fattr
->cf_atime
= cifs_NTtimeToUnix(info
->LastAccessTime
);
200 fattr
->cf_mtime
= cifs_NTtimeToUnix(info
->LastModificationTime
);
201 fattr
->cf_ctime
= cifs_NTtimeToUnix(info
->LastStatusChange
);
202 fattr
->cf_mode
= le64_to_cpu(info
->Permissions
);
205 * Since we set the inode type below we need to mask off
206 * to avoid strange results if bits set above.
208 fattr
->cf_mode
&= ~S_IFMT
;
209 switch (le32_to_cpu(info
->Type
)) {
211 fattr
->cf_mode
|= S_IFREG
;
212 fattr
->cf_dtype
= DT_REG
;
215 fattr
->cf_mode
|= S_IFLNK
;
216 fattr
->cf_dtype
= DT_LNK
;
219 fattr
->cf_mode
|= S_IFDIR
;
220 fattr
->cf_dtype
= DT_DIR
;
223 fattr
->cf_mode
|= S_IFCHR
;
224 fattr
->cf_dtype
= DT_CHR
;
225 fattr
->cf_rdev
= MKDEV(le64_to_cpu(info
->DevMajor
),
226 le64_to_cpu(info
->DevMinor
) & MINORMASK
);
229 fattr
->cf_mode
|= S_IFBLK
;
230 fattr
->cf_dtype
= DT_BLK
;
231 fattr
->cf_rdev
= MKDEV(le64_to_cpu(info
->DevMajor
),
232 le64_to_cpu(info
->DevMinor
) & MINORMASK
);
235 fattr
->cf_mode
|= S_IFIFO
;
236 fattr
->cf_dtype
= DT_FIFO
;
239 fattr
->cf_mode
|= S_IFSOCK
;
240 fattr
->cf_dtype
= DT_SOCK
;
243 /* safest to call it a file if we do not know */
244 fattr
->cf_mode
|= S_IFREG
;
245 fattr
->cf_dtype
= DT_REG
;
246 cifs_dbg(FYI
, "unknown type %d\n", le32_to_cpu(info
->Type
));
250 fattr
->cf_uid
= cifs_sb
->mnt_uid
;
251 if (!(cifs_sb
->mnt_cifs_flags
& CIFS_MOUNT_OVERR_UID
)) {
252 u64 id
= le64_to_cpu(info
->Uid
);
253 if (id
< ((uid_t
)-1)) {
254 kuid_t uid
= make_kuid(&init_user_ns
, id
);
260 fattr
->cf_gid
= cifs_sb
->mnt_gid
;
261 if (!(cifs_sb
->mnt_cifs_flags
& CIFS_MOUNT_OVERR_GID
)) {
262 u64 id
= le64_to_cpu(info
->Gid
);
263 if (id
< ((gid_t
)-1)) {
264 kgid_t gid
= make_kgid(&init_user_ns
, id
);
270 fattr
->cf_nlink
= le64_to_cpu(info
->Nlinks
);
274 * Fill a cifs_fattr struct with fake inode info.
276 * Needed to setup cifs_fattr data for the directory which is the
277 * junction to the new submount (ie to setup the fake directory
278 * which represents a DFS referral).
281 cifs_create_dfs_fattr(struct cifs_fattr
*fattr
, struct super_block
*sb
)
283 struct cifs_sb_info
*cifs_sb
= CIFS_SB(sb
);
285 cifs_dbg(FYI
, "creating fake fattr for DFS referral\n");
287 memset(fattr
, 0, sizeof(*fattr
));
288 fattr
->cf_mode
= S_IFDIR
| S_IXUGO
| S_IRWXU
;
289 fattr
->cf_uid
= cifs_sb
->mnt_uid
;
290 fattr
->cf_gid
= cifs_sb
->mnt_gid
;
291 fattr
->cf_atime
= CURRENT_TIME
;
292 fattr
->cf_ctime
= CURRENT_TIME
;
293 fattr
->cf_mtime
= CURRENT_TIME
;
295 fattr
->cf_flags
|= CIFS_FATTR_DFS_REFERRAL
;
299 cifs_get_file_info_unix(struct file
*filp
)
303 FILE_UNIX_BASIC_INFO find_data
;
304 struct cifs_fattr fattr
;
305 struct inode
*inode
= file_inode(filp
);
306 struct cifs_sb_info
*cifs_sb
= CIFS_SB(inode
->i_sb
);
307 struct cifsFileInfo
*cfile
= filp
->private_data
;
308 struct cifs_tcon
*tcon
= tlink_tcon(cfile
->tlink
);
311 rc
= CIFSSMBUnixQFileInfo(xid
, tcon
, cfile
->fid
.netfid
, &find_data
);
313 cifs_unix_basic_to_fattr(&fattr
, &find_data
, cifs_sb
);
314 } else if (rc
== -EREMOTE
) {
315 cifs_create_dfs_fattr(&fattr
, inode
->i_sb
);
319 cifs_fattr_to_inode(inode
, &fattr
);
324 int cifs_get_inode_info_unix(struct inode
**pinode
,
325 const unsigned char *full_path
,
326 struct super_block
*sb
, unsigned int xid
)
329 FILE_UNIX_BASIC_INFO find_data
;
330 struct cifs_fattr fattr
;
331 struct cifs_tcon
*tcon
;
332 struct tcon_link
*tlink
;
333 struct cifs_sb_info
*cifs_sb
= CIFS_SB(sb
);
335 cifs_dbg(FYI
, "Getting info on %s\n", full_path
);
337 tlink
= cifs_sb_tlink(cifs_sb
);
339 return PTR_ERR(tlink
);
340 tcon
= tlink_tcon(tlink
);
342 /* could have done a find first instead but this returns more info */
343 rc
= CIFSSMBUnixQPathInfo(xid
, tcon
, full_path
, &find_data
,
344 cifs_sb
->local_nls
, cifs_sb
->mnt_cifs_flags
&
345 CIFS_MOUNT_MAP_SPECIAL_CHR
);
346 cifs_put_tlink(tlink
);
349 cifs_unix_basic_to_fattr(&fattr
, &find_data
, cifs_sb
);
350 } else if (rc
== -EREMOTE
) {
351 cifs_create_dfs_fattr(&fattr
, sb
);
357 /* check for Minshall+French symlinks */
358 if (cifs_sb
->mnt_cifs_flags
& CIFS_MOUNT_MF_SYMLINKS
) {
359 int tmprc
= CIFSCheckMFSymlink(&fattr
, full_path
, cifs_sb
, xid
);
361 cifs_dbg(FYI
, "CIFSCheckMFSymlink: %d\n", tmprc
);
364 if (*pinode
== NULL
) {
366 cifs_fill_uniqueid(sb
, &fattr
);
367 *pinode
= cifs_iget(sb
, &fattr
);
371 /* we already have inode, update it */
372 cifs_fattr_to_inode(*pinode
, &fattr
);
379 cifs_sfu_type(struct cifs_fattr
*fattr
, const unsigned char *path
,
380 struct cifs_sb_info
*cifs_sb
, unsigned int xid
)
385 struct tcon_link
*tlink
;
386 struct cifs_tcon
*tcon
;
387 struct cifs_io_parms io_parms
;
389 unsigned int bytes_read
;
394 fattr
->cf_mode
&= ~S_IFMT
;
396 if (fattr
->cf_eof
== 0) {
397 fattr
->cf_mode
|= S_IFIFO
;
398 fattr
->cf_dtype
= DT_FIFO
;
400 } else if (fattr
->cf_eof
< 8) {
401 fattr
->cf_mode
|= S_IFREG
;
402 fattr
->cf_dtype
= DT_REG
;
403 return -EINVAL
; /* EOPNOTSUPP? */
406 tlink
= cifs_sb_tlink(cifs_sb
);
408 return PTR_ERR(tlink
);
409 tcon
= tlink_tcon(tlink
);
411 rc
= CIFSSMBOpen(xid
, tcon
, path
, FILE_OPEN
, GENERIC_READ
,
412 CREATE_NOT_DIR
, &netfid
, &oplock
, NULL
,
414 cifs_sb
->mnt_cifs_flags
&
415 CIFS_MOUNT_MAP_SPECIAL_CHR
);
417 int buf_type
= CIFS_NO_BUFFER
;
419 io_parms
.netfid
= netfid
;
420 io_parms
.pid
= current
->tgid
;
421 io_parms
.tcon
= tcon
;
423 io_parms
.length
= 24;
424 rc
= CIFSSMBRead(xid
, &io_parms
, &bytes_read
, &pbuf
,
426 if ((rc
== 0) && (bytes_read
>= 8)) {
427 if (memcmp("IntxBLK", pbuf
, 8) == 0) {
428 cifs_dbg(FYI
, "Block device\n");
429 fattr
->cf_mode
|= S_IFBLK
;
430 fattr
->cf_dtype
= DT_BLK
;
431 if (bytes_read
== 24) {
432 /* we have enough to decode dev num */
433 __u64 mjr
; /* major */
434 __u64 mnr
; /* minor */
435 mjr
= le64_to_cpu(*(__le64
*)(pbuf
+8));
436 mnr
= le64_to_cpu(*(__le64
*)(pbuf
+16));
437 fattr
->cf_rdev
= MKDEV(mjr
, mnr
);
439 } else if (memcmp("IntxCHR", pbuf
, 8) == 0) {
440 cifs_dbg(FYI
, "Char device\n");
441 fattr
->cf_mode
|= S_IFCHR
;
442 fattr
->cf_dtype
= DT_CHR
;
443 if (bytes_read
== 24) {
444 /* we have enough to decode dev num */
445 __u64 mjr
; /* major */
446 __u64 mnr
; /* minor */
447 mjr
= le64_to_cpu(*(__le64
*)(pbuf
+8));
448 mnr
= le64_to_cpu(*(__le64
*)(pbuf
+16));
449 fattr
->cf_rdev
= MKDEV(mjr
, mnr
);
451 } else if (memcmp("IntxLNK", pbuf
, 7) == 0) {
452 cifs_dbg(FYI
, "Symlink\n");
453 fattr
->cf_mode
|= S_IFLNK
;
454 fattr
->cf_dtype
= DT_LNK
;
456 fattr
->cf_mode
|= S_IFREG
; /* file? */
457 fattr
->cf_dtype
= DT_REG
;
461 fattr
->cf_mode
|= S_IFREG
; /* then it is a file */
462 fattr
->cf_dtype
= DT_REG
;
463 rc
= -EOPNOTSUPP
; /* or some unknown SFU type */
465 CIFSSMBClose(xid
, tcon
, netfid
);
467 cifs_put_tlink(tlink
);
471 #define SFBITS_MASK (S_ISVTX | S_ISGID | S_ISUID) /* SETFILEBITS valid bits */
474 * Fetch mode bits as provided by SFU.
476 * FIXME: Doesn't this clobber the type bit we got from cifs_sfu_type ?
478 static int cifs_sfu_mode(struct cifs_fattr
*fattr
, const unsigned char *path
,
479 struct cifs_sb_info
*cifs_sb
, unsigned int xid
)
481 #ifdef CONFIG_CIFS_XATTR
485 struct tcon_link
*tlink
;
486 struct cifs_tcon
*tcon
;
488 tlink
= cifs_sb_tlink(cifs_sb
);
490 return PTR_ERR(tlink
);
491 tcon
= tlink_tcon(tlink
);
493 rc
= CIFSSMBQAllEAs(xid
, tcon
, path
, "SETFILEBITS",
494 ea_value
, 4 /* size of buf */, cifs_sb
->local_nls
,
495 cifs_sb
->mnt_cifs_flags
&
496 CIFS_MOUNT_MAP_SPECIAL_CHR
);
497 cifs_put_tlink(tlink
);
501 mode
= le32_to_cpu(*((__le32
*)ea_value
));
502 fattr
->cf_mode
&= ~SFBITS_MASK
;
503 cifs_dbg(FYI
, "special bits 0%o org mode 0%o\n",
504 mode
, fattr
->cf_mode
);
505 fattr
->cf_mode
= (mode
& SFBITS_MASK
) | fattr
->cf_mode
;
506 cifs_dbg(FYI
, "special mode bits 0%o\n", mode
);
515 /* Fill a cifs_fattr struct with info from FILE_ALL_INFO */
517 cifs_all_info_to_fattr(struct cifs_fattr
*fattr
, FILE_ALL_INFO
*info
,
518 struct cifs_sb_info
*cifs_sb
, bool adjust_tz
)
520 struct cifs_tcon
*tcon
= cifs_sb_master_tcon(cifs_sb
);
522 memset(fattr
, 0, sizeof(*fattr
));
523 fattr
->cf_cifsattrs
= le32_to_cpu(info
->Attributes
);
524 if (info
->DeletePending
)
525 fattr
->cf_flags
|= CIFS_FATTR_DELETE_PENDING
;
527 if (info
->LastAccessTime
)
528 fattr
->cf_atime
= cifs_NTtimeToUnix(info
->LastAccessTime
);
530 fattr
->cf_atime
= CURRENT_TIME
;
532 fattr
->cf_ctime
= cifs_NTtimeToUnix(info
->ChangeTime
);
533 fattr
->cf_mtime
= cifs_NTtimeToUnix(info
->LastWriteTime
);
536 fattr
->cf_ctime
.tv_sec
+= tcon
->ses
->server
->timeAdj
;
537 fattr
->cf_mtime
.tv_sec
+= tcon
->ses
->server
->timeAdj
;
540 fattr
->cf_eof
= le64_to_cpu(info
->EndOfFile
);
541 fattr
->cf_bytes
= le64_to_cpu(info
->AllocationSize
);
542 fattr
->cf_createtime
= le64_to_cpu(info
->CreationTime
);
544 if (fattr
->cf_cifsattrs
& ATTR_DIRECTORY
) {
545 fattr
->cf_mode
= S_IFDIR
| cifs_sb
->mnt_dir_mode
;
546 fattr
->cf_dtype
= DT_DIR
;
548 * Server can return wrong NumberOfLinks value for directories
549 * when Unix extensions are disabled - fake it.
552 } else if (fattr
->cf_cifsattrs
& ATTR_REPARSE
) {
553 fattr
->cf_mode
= S_IFLNK
;
554 fattr
->cf_dtype
= DT_LNK
;
555 fattr
->cf_nlink
= le32_to_cpu(info
->NumberOfLinks
);
557 fattr
->cf_mode
= S_IFREG
| cifs_sb
->mnt_file_mode
;
558 fattr
->cf_dtype
= DT_REG
;
560 /* clear write bits if ATTR_READONLY is set */
561 if (fattr
->cf_cifsattrs
& ATTR_READONLY
)
562 fattr
->cf_mode
&= ~(S_IWUGO
);
564 fattr
->cf_nlink
= le32_to_cpu(info
->NumberOfLinks
);
565 if (fattr
->cf_nlink
< 1) {
566 cifs_dbg(1, "replacing bogus file nlink value %u\n",
572 fattr
->cf_uid
= cifs_sb
->mnt_uid
;
573 fattr
->cf_gid
= cifs_sb
->mnt_gid
;
577 cifs_get_file_info(struct file
*filp
)
581 FILE_ALL_INFO find_data
;
582 struct cifs_fattr fattr
;
583 struct inode
*inode
= file_inode(filp
);
584 struct cifs_sb_info
*cifs_sb
= CIFS_SB(inode
->i_sb
);
585 struct cifsFileInfo
*cfile
= filp
->private_data
;
586 struct cifs_tcon
*tcon
= tlink_tcon(cfile
->tlink
);
587 struct TCP_Server_Info
*server
= tcon
->ses
->server
;
589 if (!server
->ops
->query_file_info
)
593 rc
= server
->ops
->query_file_info(xid
, tcon
, &cfile
->fid
, &find_data
);
596 cifs_all_info_to_fattr(&fattr
, &find_data
, cifs_sb
, false);
599 cifs_create_dfs_fattr(&fattr
, inode
->i_sb
);
605 * FIXME: legacy server -- fall back to path-based call?
606 * for now, just skip revalidating and mark inode for
610 CIFS_I(inode
)->time
= 0;
616 * don't bother with SFU junk here -- just mark inode as needing
619 fattr
.cf_uniqueid
= CIFS_I(inode
)->uniqueid
;
620 fattr
.cf_flags
|= CIFS_FATTR_NEED_REVAL
;
621 cifs_fattr_to_inode(inode
, &fattr
);
628 cifs_get_inode_info(struct inode
**inode
, const char *full_path
,
629 FILE_ALL_INFO
*data
, struct super_block
*sb
, int xid
,
632 bool validinum
= false;
634 int rc
= 0, tmprc
= ENOSYS
;
635 struct cifs_tcon
*tcon
;
636 struct TCP_Server_Info
*server
;
637 struct tcon_link
*tlink
;
638 struct cifs_sb_info
*cifs_sb
= CIFS_SB(sb
);
640 bool adjust_tz
= false;
641 struct cifs_fattr fattr
;
642 struct cifs_search_info
*srchinf
= NULL
;
644 tlink
= cifs_sb_tlink(cifs_sb
);
646 return PTR_ERR(tlink
);
647 tcon
= tlink_tcon(tlink
);
648 server
= tcon
->ses
->server
;
650 cifs_dbg(FYI
, "Getting info on %s\n", full_path
);
652 if ((data
== NULL
) && (*inode
!= NULL
)) {
653 if (CIFS_CACHE_READ(CIFS_I(*inode
))) {
654 cifs_dbg(FYI
, "No need to revalidate cached inode sizes\n");
659 /* if inode info is not passed, get it from server */
661 if (!server
->ops
->query_path_info
) {
665 buf
= kmalloc(sizeof(FILE_ALL_INFO
), GFP_KERNEL
);
670 data
= (FILE_ALL_INFO
*)buf
;
671 rc
= server
->ops
->query_path_info(xid
, tcon
, cifs_sb
, full_path
,
676 cifs_all_info_to_fattr(&fattr
, (FILE_ALL_INFO
*)data
, cifs_sb
,
678 } else if (rc
== -EREMOTE
) {
679 cifs_create_dfs_fattr(&fattr
, sb
);
681 } else if (rc
== -EACCES
&& backup_cred(cifs_sb
)) {
682 srchinf
= kzalloc(sizeof(struct cifs_search_info
),
684 if (srchinf
== NULL
) {
689 srchinf
->endOfSearch
= false;
690 srchinf
->info_level
= SMB_FIND_FILE_ID_FULL_DIR_INFO
;
692 srchflgs
= CIFS_SEARCH_CLOSE_ALWAYS
|
693 CIFS_SEARCH_CLOSE_AT_END
|
694 CIFS_SEARCH_BACKUP_SEARCH
;
696 rc
= CIFSFindFirst(xid
, tcon
, full_path
,
697 cifs_sb
, NULL
, srchflgs
, srchinf
, false);
700 (FILE_ALL_INFO
*)srchinf
->srch_entries_start
;
702 cifs_dir_info_to_fattr(&fattr
,
703 (FILE_DIRECTORY_INFO
*)data
, cifs_sb
);
704 fattr
.cf_uniqueid
= le64_to_cpu(
705 ((SEARCH_ID_FULL_DIR_INFO
*)data
)->UniqueId
);
708 cifs_buf_release(srchinf
->ntwrk_buf_start
);
715 * If an inode wasn't passed in, then get the inode number
717 * Is an i_ino of zero legal? Can we use that to check if the server
718 * supports returning inode numbers? Are there other sanity checks we
719 * can use to ensure that the server is really filling in that field?
721 if (*inode
== NULL
) {
722 if (cifs_sb
->mnt_cifs_flags
& CIFS_MOUNT_SERVER_INUM
) {
723 if (validinum
== false) {
724 if (server
->ops
->get_srv_inum
)
725 tmprc
= server
->ops
->get_srv_inum(xid
,
726 tcon
, cifs_sb
, full_path
,
727 &fattr
.cf_uniqueid
, data
);
729 cifs_dbg(FYI
, "GetSrvInodeNum rc %d\n",
731 fattr
.cf_uniqueid
= iunique(sb
, ROOT_I
);
732 cifs_autodisable_serverino(cifs_sb
);
736 fattr
.cf_uniqueid
= iunique(sb
, ROOT_I
);
738 fattr
.cf_uniqueid
= CIFS_I(*inode
)->uniqueid
;
740 /* query for SFU type info if supported and needed */
741 if (fattr
.cf_cifsattrs
& ATTR_SYSTEM
&&
742 cifs_sb
->mnt_cifs_flags
& CIFS_MOUNT_UNX_EMUL
) {
743 tmprc
= cifs_sfu_type(&fattr
, full_path
, cifs_sb
, xid
);
745 cifs_dbg(FYI
, "cifs_sfu_type failed: %d\n", tmprc
);
748 #ifdef CONFIG_CIFS_ACL
749 /* fill in 0777 bits from ACL */
750 if (cifs_sb
->mnt_cifs_flags
& CIFS_MOUNT_CIFS_ACL
) {
751 rc
= cifs_acl_to_fattr(cifs_sb
, &fattr
, *inode
, full_path
, fid
);
753 cifs_dbg(FYI
, "%s: Getting ACL failed with error: %d\n",
758 #endif /* CONFIG_CIFS_ACL */
760 /* fill in remaining high mode bits e.g. SUID, VTX */
761 if (cifs_sb
->mnt_cifs_flags
& CIFS_MOUNT_UNX_EMUL
)
762 cifs_sfu_mode(&fattr
, full_path
, cifs_sb
, xid
);
764 /* check for Minshall+French symlinks */
765 if (cifs_sb
->mnt_cifs_flags
& CIFS_MOUNT_MF_SYMLINKS
) {
766 tmprc
= CIFSCheckMFSymlink(&fattr
, full_path
, cifs_sb
, xid
);
768 cifs_dbg(FYI
, "CIFSCheckMFSymlink: %d\n", tmprc
);
772 *inode
= cifs_iget(sb
, &fattr
);
776 cifs_fattr_to_inode(*inode
, &fattr
);
781 cifs_put_tlink(tlink
);
785 static const struct inode_operations cifs_ipc_inode_ops
= {
786 .lookup
= cifs_lookup
,
790 cifs_find_inode(struct inode
*inode
, void *opaque
)
792 struct cifs_fattr
*fattr
= (struct cifs_fattr
*) opaque
;
794 /* don't match inode with different uniqueid */
795 if (CIFS_I(inode
)->uniqueid
!= fattr
->cf_uniqueid
)
798 /* use createtime like an i_generation field */
799 if (CIFS_I(inode
)->createtime
!= fattr
->cf_createtime
)
802 /* don't match inode of different type */
803 if ((inode
->i_mode
& S_IFMT
) != (fattr
->cf_mode
& S_IFMT
))
806 /* if it's not a directory or has no dentries, then flag it */
807 if (S_ISDIR(inode
->i_mode
) && !hlist_empty(&inode
->i_dentry
))
808 fattr
->cf_flags
|= CIFS_FATTR_INO_COLLISION
;
814 cifs_init_inode(struct inode
*inode
, void *opaque
)
816 struct cifs_fattr
*fattr
= (struct cifs_fattr
*) opaque
;
818 CIFS_I(inode
)->uniqueid
= fattr
->cf_uniqueid
;
819 CIFS_I(inode
)->createtime
= fattr
->cf_createtime
;
824 * walk dentry list for an inode and report whether it has aliases that
825 * are hashed. We use this to determine if a directory inode can actually
829 inode_has_hashed_dentries(struct inode
*inode
)
831 struct dentry
*dentry
;
833 spin_lock(&inode
->i_lock
);
834 hlist_for_each_entry(dentry
, &inode
->i_dentry
, d_alias
) {
835 if (!d_unhashed(dentry
) || IS_ROOT(dentry
)) {
836 spin_unlock(&inode
->i_lock
);
840 spin_unlock(&inode
->i_lock
);
844 /* Given fattrs, get a corresponding inode */
846 cifs_iget(struct super_block
*sb
, struct cifs_fattr
*fattr
)
852 cifs_dbg(FYI
, "looking for uniqueid=%llu\n", fattr
->cf_uniqueid
);
854 /* hash down to 32-bits on 32-bit arch */
855 hash
= cifs_uniqueid_to_ino_t(fattr
->cf_uniqueid
);
857 inode
= iget5_locked(sb
, hash
, cifs_find_inode
, cifs_init_inode
, fattr
);
859 /* was there a potentially problematic inode collision? */
860 if (fattr
->cf_flags
& CIFS_FATTR_INO_COLLISION
) {
861 fattr
->cf_flags
&= ~CIFS_FATTR_INO_COLLISION
;
863 if (inode_has_hashed_dentries(inode
)) {
864 cifs_autodisable_serverino(CIFS_SB(sb
));
866 fattr
->cf_uniqueid
= iunique(sb
, ROOT_I
);
867 goto retry_iget5_locked
;
871 cifs_fattr_to_inode(inode
, fattr
);
872 if (sb
->s_flags
& MS_NOATIME
)
873 inode
->i_flags
|= S_NOATIME
| S_NOCMTIME
;
874 if (inode
->i_state
& I_NEW
) {
876 if (S_ISREG(inode
->i_mode
))
877 inode
->i_data
.backing_dev_info
= sb
->s_bdi
;
878 #ifdef CONFIG_CIFS_FSCACHE
879 /* initialize per-inode cache cookie pointer */
880 CIFS_I(inode
)->fscache
= NULL
;
882 unlock_new_inode(inode
);
889 /* gets root inode */
890 struct inode
*cifs_root_iget(struct super_block
*sb
)
893 struct cifs_sb_info
*cifs_sb
= CIFS_SB(sb
);
894 struct inode
*inode
= NULL
;
896 struct cifs_tcon
*tcon
= cifs_sb_master_tcon(cifs_sb
);
900 rc
= cifs_get_inode_info_unix(&inode
, "", sb
, xid
);
902 rc
= cifs_get_inode_info(&inode
, "", NULL
, sb
, xid
, NULL
);
909 #ifdef CONFIG_CIFS_FSCACHE
910 /* populate tcon->resource_id */
911 tcon
->resource_id
= CIFS_I(inode
)->uniqueid
;
914 if (rc
&& tcon
->ipc
) {
915 cifs_dbg(FYI
, "ipc connection - fake read inode\n");
916 spin_lock(&inode
->i_lock
);
917 inode
->i_mode
|= S_IFDIR
;
919 inode
->i_op
= &cifs_ipc_inode_ops
;
920 inode
->i_fop
= &simple_dir_operations
;
921 inode
->i_uid
= cifs_sb
->mnt_uid
;
922 inode
->i_gid
= cifs_sb
->mnt_gid
;
923 spin_unlock(&inode
->i_lock
);
930 /* can not call macro free_xid here since in a void func
931 * TODO: This is no longer true
938 cifs_set_file_info(struct inode
*inode
, struct iattr
*attrs
, unsigned int xid
,
939 char *full_path
, __u32 dosattr
)
941 bool set_time
= false;
942 struct cifs_sb_info
*cifs_sb
= CIFS_SB(inode
->i_sb
);
943 struct TCP_Server_Info
*server
;
944 FILE_BASIC_INFO info_buf
;
949 server
= cifs_sb_master_tcon(cifs_sb
)->ses
->server
;
950 if (!server
->ops
->set_file_info
)
953 if (attrs
->ia_valid
& ATTR_ATIME
) {
955 info_buf
.LastAccessTime
=
956 cpu_to_le64(cifs_UnixTimeToNT(attrs
->ia_atime
));
958 info_buf
.LastAccessTime
= 0;
960 if (attrs
->ia_valid
& ATTR_MTIME
) {
962 info_buf
.LastWriteTime
=
963 cpu_to_le64(cifs_UnixTimeToNT(attrs
->ia_mtime
));
965 info_buf
.LastWriteTime
= 0;
968 * Samba throws this field away, but windows may actually use it.
969 * Do not set ctime unless other time stamps are changed explicitly
970 * (i.e. by utimes()) since we would then have a mix of client and
973 if (set_time
&& (attrs
->ia_valid
& ATTR_CTIME
)) {
974 cifs_dbg(FYI
, "CIFS - CTIME changed\n");
975 info_buf
.ChangeTime
=
976 cpu_to_le64(cifs_UnixTimeToNT(attrs
->ia_ctime
));
978 info_buf
.ChangeTime
= 0;
980 info_buf
.CreationTime
= 0; /* don't change */
981 info_buf
.Attributes
= cpu_to_le32(dosattr
);
983 return server
->ops
->set_file_info(inode
, full_path
, &info_buf
, xid
);
987 * Open the given file (if it isn't already), set the DELETE_ON_CLOSE bit
988 * and rename it to a random name that hopefully won't conflict with
992 cifs_rename_pending_delete(const char *full_path
, struct dentry
*dentry
,
993 const unsigned int xid
)
998 struct inode
*inode
= dentry
->d_inode
;
999 struct cifsInodeInfo
*cifsInode
= CIFS_I(inode
);
1000 struct cifs_sb_info
*cifs_sb
= CIFS_SB(inode
->i_sb
);
1001 struct tcon_link
*tlink
;
1002 struct cifs_tcon
*tcon
;
1003 __u32 dosattr
, origattr
;
1004 FILE_BASIC_INFO
*info_buf
= NULL
;
1006 tlink
= cifs_sb_tlink(cifs_sb
);
1008 return PTR_ERR(tlink
);
1009 tcon
= tlink_tcon(tlink
);
1012 * We cannot rename the file if the server doesn't support
1013 * CAP_INFOLEVEL_PASSTHRU
1015 if (!(tcon
->ses
->capabilities
& CAP_INFOLEVEL_PASSTHRU
)) {
1020 rc
= CIFSSMBOpen(xid
, tcon
, full_path
, FILE_OPEN
,
1021 DELETE
|FILE_WRITE_ATTRIBUTES
, CREATE_NOT_DIR
,
1022 &netfid
, &oplock
, NULL
, cifs_sb
->local_nls
,
1023 cifs_sb
->mnt_cifs_flags
& CIFS_MOUNT_MAP_SPECIAL_CHR
);
1027 origattr
= cifsInode
->cifsAttrs
;
1029 origattr
|= ATTR_NORMAL
;
1031 dosattr
= origattr
& ~ATTR_READONLY
;
1033 dosattr
|= ATTR_NORMAL
;
1034 dosattr
|= ATTR_HIDDEN
;
1036 /* set ATTR_HIDDEN and clear ATTR_READONLY, but only if needed */
1037 if (dosattr
!= origattr
) {
1038 info_buf
= kzalloc(sizeof(*info_buf
), GFP_KERNEL
);
1039 if (info_buf
== NULL
) {
1043 info_buf
->Attributes
= cpu_to_le32(dosattr
);
1044 rc
= CIFSSMBSetFileInfo(xid
, tcon
, info_buf
, netfid
,
1046 /* although we would like to mark the file hidden
1047 if that fails we will still try to rename it */
1049 cifsInode
->cifsAttrs
= dosattr
;
1051 dosattr
= origattr
; /* since not able to change them */
1054 /* rename the file */
1055 rc
= CIFSSMBRenameOpenFile(xid
, tcon
, netfid
, NULL
, cifs_sb
->local_nls
,
1056 cifs_sb
->mnt_cifs_flags
&
1057 CIFS_MOUNT_MAP_SPECIAL_CHR
);
1063 /* try to set DELETE_ON_CLOSE */
1064 if (!cifsInode
->delete_pending
) {
1065 rc
= CIFSSMBSetFileDisposition(xid
, tcon
, true, netfid
,
1068 * some samba versions return -ENOENT when we try to set the
1069 * file disposition here. Likely a samba bug, but work around
1070 * it for now. This means that some cifsXXX files may hang
1071 * around after they shouldn't.
1073 * BB: remove this hack after more servers have the fix
1081 cifsInode
->delete_pending
= true;
1085 CIFSSMBClose(xid
, tcon
, netfid
);
1088 cifs_put_tlink(tlink
);
1092 * reset everything back to the original state. Don't bother
1093 * dealing with errors here since we can't do anything about
1097 CIFSSMBRenameOpenFile(xid
, tcon
, netfid
, dentry
->d_name
.name
,
1098 cifs_sb
->local_nls
, cifs_sb
->mnt_cifs_flags
&
1099 CIFS_MOUNT_MAP_SPECIAL_CHR
);
1101 if (dosattr
!= origattr
) {
1102 info_buf
->Attributes
= cpu_to_le32(origattr
);
1103 if (!CIFSSMBSetFileInfo(xid
, tcon
, info_buf
, netfid
,
1105 cifsInode
->cifsAttrs
= origattr
;
1111 /* copied from fs/nfs/dir.c with small changes */
1113 cifs_drop_nlink(struct inode
*inode
)
1115 spin_lock(&inode
->i_lock
);
1116 if (inode
->i_nlink
> 0)
1118 spin_unlock(&inode
->i_lock
);
1122 * If dentry->d_inode is null (usually meaning the cached dentry
1123 * is a negative dentry) then we would attempt a standard SMB delete, but
1124 * if that fails we can not attempt the fall back mechanisms on EACCESS
1125 * but will return the EACCESS to the caller. Note that the VFS does not call
1126 * unlink on negative dentries currently.
1128 int cifs_unlink(struct inode
*dir
, struct dentry
*dentry
)
1132 char *full_path
= NULL
;
1133 struct inode
*inode
= dentry
->d_inode
;
1134 struct cifsInodeInfo
*cifs_inode
;
1135 struct super_block
*sb
= dir
->i_sb
;
1136 struct cifs_sb_info
*cifs_sb
= CIFS_SB(sb
);
1137 struct tcon_link
*tlink
;
1138 struct cifs_tcon
*tcon
;
1139 struct TCP_Server_Info
*server
;
1140 struct iattr
*attrs
= NULL
;
1141 __u32 dosattr
= 0, origattr
= 0;
1143 cifs_dbg(FYI
, "cifs_unlink, dir=0x%p, dentry=0x%p\n", dir
, dentry
);
1145 tlink
= cifs_sb_tlink(cifs_sb
);
1147 return PTR_ERR(tlink
);
1148 tcon
= tlink_tcon(tlink
);
1149 server
= tcon
->ses
->server
;
1153 /* Unlink can be called from rename so we can not take the
1154 * sb->s_vfs_rename_mutex here */
1155 full_path
= build_path_from_dentry(dentry
);
1156 if (full_path
== NULL
) {
1161 if (cap_unix(tcon
->ses
) && (CIFS_UNIX_POSIX_PATH_OPS_CAP
&
1162 le64_to_cpu(tcon
->fsUnixInfo
.Capability
))) {
1163 rc
= CIFSPOSIXDelFile(xid
, tcon
, full_path
,
1164 SMB_POSIX_UNLINK_FILE_TARGET
, cifs_sb
->local_nls
,
1165 cifs_sb
->mnt_cifs_flags
& CIFS_MOUNT_MAP_SPECIAL_CHR
);
1166 cifs_dbg(FYI
, "posix del rc %d\n", rc
);
1167 if ((rc
== 0) || (rc
== -ENOENT
))
1168 goto psx_del_no_retry
;
1172 if (!server
->ops
->unlink
) {
1174 goto psx_del_no_retry
;
1177 rc
= server
->ops
->unlink(xid
, tcon
, full_path
, cifs_sb
);
1182 cifs_drop_nlink(inode
);
1183 } else if (rc
== -ENOENT
) {
1185 } else if (rc
== -EBUSY
) {
1186 if (server
->ops
->rename_pending_delete
) {
1187 rc
= server
->ops
->rename_pending_delete(full_path
,
1190 cifs_drop_nlink(inode
);
1192 } else if ((rc
== -EACCES
) && (dosattr
== 0) && inode
) {
1193 attrs
= kzalloc(sizeof(*attrs
), GFP_KERNEL
);
1194 if (attrs
== NULL
) {
1199 /* try to reset dos attributes */
1200 cifs_inode
= CIFS_I(inode
);
1201 origattr
= cifs_inode
->cifsAttrs
;
1203 origattr
|= ATTR_NORMAL
;
1204 dosattr
= origattr
& ~ATTR_READONLY
;
1206 dosattr
|= ATTR_NORMAL
;
1207 dosattr
|= ATTR_HIDDEN
;
1209 rc
= cifs_set_file_info(inode
, attrs
, xid
, full_path
, dosattr
);
1213 goto retry_std_delete
;
1216 /* undo the setattr if we errored out and it's needed */
1217 if (rc
!= 0 && dosattr
!= 0)
1218 cifs_set_file_info(inode
, attrs
, xid
, full_path
, origattr
);
1222 cifs_inode
= CIFS_I(inode
);
1223 cifs_inode
->time
= 0; /* will force revalidate to get info
1225 inode
->i_ctime
= current_fs_time(sb
);
1227 dir
->i_ctime
= dir
->i_mtime
= current_fs_time(sb
);
1228 cifs_inode
= CIFS_I(dir
);
1229 CIFS_I(dir
)->time
= 0; /* force revalidate of dir as well */
1234 cifs_put_tlink(tlink
);
1239 cifs_mkdir_qinfo(struct inode
*parent
, struct dentry
*dentry
, umode_t mode
,
1240 const char *full_path
, struct cifs_sb_info
*cifs_sb
,
1241 struct cifs_tcon
*tcon
, const unsigned int xid
)
1244 struct inode
*inode
= NULL
;
1247 rc
= cifs_get_inode_info_unix(&inode
, full_path
, parent
->i_sb
,
1250 rc
= cifs_get_inode_info(&inode
, full_path
, NULL
, parent
->i_sb
,
1257 * setting nlink not necessary except in cases where we failed to get it
1258 * from the server or was set bogus. Also, since this is a brand new
1259 * inode, no need to grab the i_lock before setting the i_nlink.
1261 if (inode
->i_nlink
< 2)
1262 set_nlink(inode
, 2);
1263 mode
&= ~current_umask();
1264 /* must turn on setgid bit if parent dir has it */
1265 if (parent
->i_mode
& S_ISGID
)
1268 if (tcon
->unix_ext
) {
1269 struct cifs_unix_set_info_args args
= {
1271 .ctime
= NO_CHANGE_64
,
1272 .atime
= NO_CHANGE_64
,
1273 .mtime
= NO_CHANGE_64
,
1276 if (cifs_sb
->mnt_cifs_flags
& CIFS_MOUNT_SET_UID
) {
1277 args
.uid
= current_fsuid();
1278 if (parent
->i_mode
& S_ISGID
)
1279 args
.gid
= parent
->i_gid
;
1281 args
.gid
= current_fsgid();
1283 args
.uid
= INVALID_UID
; /* no change */
1284 args
.gid
= INVALID_GID
; /* no change */
1286 CIFSSMBUnixSetPathInfo(xid
, tcon
, full_path
, &args
,
1288 cifs_sb
->mnt_cifs_flags
&
1289 CIFS_MOUNT_MAP_SPECIAL_CHR
);
1291 struct TCP_Server_Info
*server
= tcon
->ses
->server
;
1292 if (!(cifs_sb
->mnt_cifs_flags
& CIFS_MOUNT_CIFS_ACL
) &&
1293 (mode
& S_IWUGO
) == 0 && server
->ops
->mkdir_setinfo
)
1294 server
->ops
->mkdir_setinfo(inode
, full_path
, cifs_sb
,
1296 if (cifs_sb
->mnt_cifs_flags
& CIFS_MOUNT_DYNPERM
)
1297 inode
->i_mode
= (mode
| S_IFDIR
);
1299 if (cifs_sb
->mnt_cifs_flags
& CIFS_MOUNT_SET_UID
) {
1300 inode
->i_uid
= current_fsuid();
1301 if (inode
->i_mode
& S_ISGID
)
1302 inode
->i_gid
= parent
->i_gid
;
1304 inode
->i_gid
= current_fsgid();
1307 d_instantiate(dentry
, inode
);
1312 cifs_posix_mkdir(struct inode
*inode
, struct dentry
*dentry
, umode_t mode
,
1313 const char *full_path
, struct cifs_sb_info
*cifs_sb
,
1314 struct cifs_tcon
*tcon
, const unsigned int xid
)
1318 FILE_UNIX_BASIC_INFO
*info
= NULL
;
1319 struct inode
*newinode
= NULL
;
1320 struct cifs_fattr fattr
;
1322 info
= kzalloc(sizeof(FILE_UNIX_BASIC_INFO
), GFP_KERNEL
);
1325 goto posix_mkdir_out
;
1328 mode
&= ~current_umask();
1329 rc
= CIFSPOSIXCreate(xid
, tcon
, SMB_O_DIRECTORY
| SMB_O_CREAT
, mode
,
1330 NULL
/* netfid */, info
, &oplock
, full_path
,
1331 cifs_sb
->local_nls
, cifs_sb
->mnt_cifs_flags
&
1332 CIFS_MOUNT_MAP_SPECIAL_CHR
);
1333 if (rc
== -EOPNOTSUPP
)
1334 goto posix_mkdir_out
;
1336 cifs_dbg(FYI
, "posix mkdir returned 0x%x\n", rc
);
1338 goto posix_mkdir_out
;
1341 if (info
->Type
== cpu_to_le32(-1))
1342 /* no return info, go query for it */
1343 goto posix_mkdir_get_info
;
1345 * BB check (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_SET_UID ) to see if
1346 * need to set uid/gid.
1349 cifs_unix_basic_to_fattr(&fattr
, info
, cifs_sb
);
1350 cifs_fill_uniqueid(inode
->i_sb
, &fattr
);
1351 newinode
= cifs_iget(inode
->i_sb
, &fattr
);
1353 goto posix_mkdir_get_info
;
1355 d_instantiate(dentry
, newinode
);
1357 #ifdef CONFIG_CIFS_DEBUG2
1358 cifs_dbg(FYI
, "instantiated dentry %p %s to inode %p\n",
1359 dentry
, dentry
->d_name
.name
, newinode
);
1361 if (newinode
->i_nlink
!= 2)
1362 cifs_dbg(FYI
, "unexpected number of links %d\n",
1369 posix_mkdir_get_info
:
1370 rc
= cifs_mkdir_qinfo(inode
, dentry
, mode
, full_path
, cifs_sb
, tcon
,
1372 goto posix_mkdir_out
;
1375 int cifs_mkdir(struct inode
*inode
, struct dentry
*direntry
, umode_t mode
)
1379 struct cifs_sb_info
*cifs_sb
;
1380 struct tcon_link
*tlink
;
1381 struct cifs_tcon
*tcon
;
1382 struct TCP_Server_Info
*server
;
1385 cifs_dbg(FYI
, "In cifs_mkdir, mode = 0x%hx inode = 0x%p\n",
1388 cifs_sb
= CIFS_SB(inode
->i_sb
);
1389 tlink
= cifs_sb_tlink(cifs_sb
);
1391 return PTR_ERR(tlink
);
1392 tcon
= tlink_tcon(tlink
);
1396 full_path
= build_path_from_dentry(direntry
);
1397 if (full_path
== NULL
) {
1402 if (cap_unix(tcon
->ses
) && (CIFS_UNIX_POSIX_PATH_OPS_CAP
&
1403 le64_to_cpu(tcon
->fsUnixInfo
.Capability
))) {
1404 rc
= cifs_posix_mkdir(inode
, direntry
, mode
, full_path
, cifs_sb
,
1406 if (rc
!= -EOPNOTSUPP
)
1410 server
= tcon
->ses
->server
;
1412 if (!server
->ops
->mkdir
) {
1417 /* BB add setting the equivalent of mode via CreateX w/ACLs */
1418 rc
= server
->ops
->mkdir(xid
, tcon
, full_path
, cifs_sb
);
1420 cifs_dbg(FYI
, "cifs_mkdir returned 0x%x\n", rc
);
1425 rc
= cifs_mkdir_qinfo(inode
, direntry
, mode
, full_path
, cifs_sb
, tcon
,
1429 * Force revalidate to get parent dir info when needed since cached
1430 * attributes are invalid now.
1432 CIFS_I(inode
)->time
= 0;
1435 cifs_put_tlink(tlink
);
1439 int cifs_rmdir(struct inode
*inode
, struct dentry
*direntry
)
1443 struct cifs_sb_info
*cifs_sb
;
1444 struct tcon_link
*tlink
;
1445 struct cifs_tcon
*tcon
;
1446 struct TCP_Server_Info
*server
;
1447 char *full_path
= NULL
;
1448 struct cifsInodeInfo
*cifsInode
;
1450 cifs_dbg(FYI
, "cifs_rmdir, inode = 0x%p\n", inode
);
1454 full_path
= build_path_from_dentry(direntry
);
1455 if (full_path
== NULL
) {
1460 cifs_sb
= CIFS_SB(inode
->i_sb
);
1461 tlink
= cifs_sb_tlink(cifs_sb
);
1462 if (IS_ERR(tlink
)) {
1463 rc
= PTR_ERR(tlink
);
1466 tcon
= tlink_tcon(tlink
);
1467 server
= tcon
->ses
->server
;
1469 if (!server
->ops
->rmdir
) {
1471 cifs_put_tlink(tlink
);
1475 rc
= server
->ops
->rmdir(xid
, tcon
, full_path
, cifs_sb
);
1476 cifs_put_tlink(tlink
);
1479 spin_lock(&direntry
->d_inode
->i_lock
);
1480 i_size_write(direntry
->d_inode
, 0);
1481 clear_nlink(direntry
->d_inode
);
1482 spin_unlock(&direntry
->d_inode
->i_lock
);
1485 cifsInode
= CIFS_I(direntry
->d_inode
);
1486 /* force revalidate to go get info when needed */
1487 cifsInode
->time
= 0;
1489 cifsInode
= CIFS_I(inode
);
1491 * Force revalidate to get parent dir info when needed since cached
1492 * attributes are invalid now.
1494 cifsInode
->time
= 0;
1496 direntry
->d_inode
->i_ctime
= inode
->i_ctime
= inode
->i_mtime
=
1497 current_fs_time(inode
->i_sb
);
1506 cifs_do_rename(const unsigned int xid
, struct dentry
*from_dentry
,
1507 const char *from_path
, struct dentry
*to_dentry
,
1508 const char *to_path
)
1510 struct cifs_sb_info
*cifs_sb
= CIFS_SB(from_dentry
->d_sb
);
1511 struct tcon_link
*tlink
;
1512 struct cifs_tcon
*tcon
;
1513 struct TCP_Server_Info
*server
;
1517 tlink
= cifs_sb_tlink(cifs_sb
);
1519 return PTR_ERR(tlink
);
1520 tcon
= tlink_tcon(tlink
);
1521 server
= tcon
->ses
->server
;
1523 if (!server
->ops
->rename
)
1526 /* try path-based rename first */
1527 rc
= server
->ops
->rename(xid
, tcon
, from_path
, to_path
, cifs_sb
);
1530 * Don't bother with rename by filehandle unless file is busy and
1531 * source. Note that cross directory moves do not work with
1532 * rename by filehandle to various Windows servers.
1534 if (rc
== 0 || rc
!= -EBUSY
)
1535 goto do_rename_exit
;
1537 /* open-file renames don't work across directories */
1538 if (to_dentry
->d_parent
!= from_dentry
->d_parent
)
1539 goto do_rename_exit
;
1541 /* open the file to be renamed -- we need DELETE perms */
1542 rc
= CIFSSMBOpen(xid
, tcon
, from_path
, FILE_OPEN
, DELETE
,
1543 CREATE_NOT_DIR
, &srcfid
, &oplock
, NULL
,
1544 cifs_sb
->local_nls
, cifs_sb
->mnt_cifs_flags
&
1545 CIFS_MOUNT_MAP_SPECIAL_CHR
);
1547 rc
= CIFSSMBRenameOpenFile(xid
, tcon
, srcfid
,
1548 (const char *) to_dentry
->d_name
.name
,
1549 cifs_sb
->local_nls
, cifs_sb
->mnt_cifs_flags
&
1550 CIFS_MOUNT_MAP_SPECIAL_CHR
);
1551 CIFSSMBClose(xid
, tcon
, srcfid
);
1554 cifs_put_tlink(tlink
);
1559 cifs_rename(struct inode
*source_dir
, struct dentry
*source_dentry
,
1560 struct inode
*target_dir
, struct dentry
*target_dentry
)
1562 char *from_name
= NULL
;
1563 char *to_name
= NULL
;
1564 struct cifs_sb_info
*cifs_sb
;
1565 struct tcon_link
*tlink
;
1566 struct cifs_tcon
*tcon
;
1567 FILE_UNIX_BASIC_INFO
*info_buf_source
= NULL
;
1568 FILE_UNIX_BASIC_INFO
*info_buf_target
;
1572 cifs_sb
= CIFS_SB(source_dir
->i_sb
);
1573 tlink
= cifs_sb_tlink(cifs_sb
);
1575 return PTR_ERR(tlink
);
1576 tcon
= tlink_tcon(tlink
);
1581 * we already have the rename sem so we do not need to
1582 * grab it again here to protect the path integrity
1584 from_name
= build_path_from_dentry(source_dentry
);
1585 if (from_name
== NULL
) {
1587 goto cifs_rename_exit
;
1590 to_name
= build_path_from_dentry(target_dentry
);
1591 if (to_name
== NULL
) {
1593 goto cifs_rename_exit
;
1596 rc
= cifs_do_rename(xid
, source_dentry
, from_name
, target_dentry
,
1599 if (rc
== -EEXIST
&& tcon
->unix_ext
) {
1601 * Are src and dst hardlinks of same inode? We can only tell
1602 * with unix extensions enabled.
1605 kmalloc(2 * sizeof(FILE_UNIX_BASIC_INFO
),
1607 if (info_buf_source
== NULL
) {
1609 goto cifs_rename_exit
;
1612 info_buf_target
= info_buf_source
+ 1;
1613 tmprc
= CIFSSMBUnixQPathInfo(xid
, tcon
, from_name
,
1616 cifs_sb
->mnt_cifs_flags
&
1617 CIFS_MOUNT_MAP_SPECIAL_CHR
);
1621 tmprc
= CIFSSMBUnixQPathInfo(xid
, tcon
, to_name
,
1624 cifs_sb
->mnt_cifs_flags
&
1625 CIFS_MOUNT_MAP_SPECIAL_CHR
);
1627 if (tmprc
== 0 && (info_buf_source
->UniqueId
==
1628 info_buf_target
->UniqueId
)) {
1629 /* same file, POSIX says that this is a noop */
1631 goto cifs_rename_exit
;
1635 * else ... BB we could add the same check for Windows by
1636 * checking the UniqueId via FILE_INTERNAL_INFO
1640 /* Try unlinking the target dentry if it's not negative */
1641 if (target_dentry
->d_inode
&& (rc
== -EACCES
|| rc
== -EEXIST
)) {
1642 tmprc
= cifs_unlink(target_dir
, target_dentry
);
1644 goto cifs_rename_exit
;
1645 rc
= cifs_do_rename(xid
, source_dentry
, from_name
,
1646 target_dentry
, to_name
);
1650 kfree(info_buf_source
);
1654 cifs_put_tlink(tlink
);
1659 cifs_inode_needs_reval(struct inode
*inode
)
1661 struct cifsInodeInfo
*cifs_i
= CIFS_I(inode
);
1662 struct cifs_sb_info
*cifs_sb
= CIFS_SB(inode
->i_sb
);
1664 if (CIFS_CACHE_READ(cifs_i
))
1667 if (!lookupCacheEnabled
)
1670 if (cifs_i
->time
== 0)
1673 if (!time_in_range(jiffies
, cifs_i
->time
,
1674 cifs_i
->time
+ cifs_sb
->actimeo
))
1677 /* hardlinked files w/ noserverino get "special" treatment */
1678 if (!(cifs_sb
->mnt_cifs_flags
& CIFS_MOUNT_SERVER_INUM
) &&
1679 S_ISREG(inode
->i_mode
) && inode
->i_nlink
!= 1)
1686 * Zap the cache. Called when invalid_mapping flag is set.
1689 cifs_invalidate_mapping(struct inode
*inode
)
1692 struct cifsInodeInfo
*cifs_i
= CIFS_I(inode
);
1694 cifs_i
->invalid_mapping
= false;
1696 if (inode
->i_mapping
&& inode
->i_mapping
->nrpages
!= 0) {
1697 rc
= invalidate_inode_pages2(inode
->i_mapping
);
1699 cifs_dbg(VFS
, "%s: could not invalidate inode %p\n",
1701 cifs_i
->invalid_mapping
= true;
1705 cifs_fscache_reset_inode_cookie(inode
);
1709 int cifs_revalidate_file_attr(struct file
*filp
)
1712 struct inode
*inode
= file_inode(filp
);
1713 struct cifsFileInfo
*cfile
= (struct cifsFileInfo
*) filp
->private_data
;
1715 if (!cifs_inode_needs_reval(inode
))
1718 if (tlink_tcon(cfile
->tlink
)->unix_ext
)
1719 rc
= cifs_get_file_info_unix(filp
);
1721 rc
= cifs_get_file_info(filp
);
1726 int cifs_revalidate_dentry_attr(struct dentry
*dentry
)
1730 struct inode
*inode
= dentry
->d_inode
;
1731 struct super_block
*sb
= dentry
->d_sb
;
1732 char *full_path
= NULL
;
1737 if (!cifs_inode_needs_reval(inode
))
1742 /* can not safely grab the rename sem here if rename calls revalidate
1743 since that would deadlock */
1744 full_path
= build_path_from_dentry(dentry
);
1745 if (full_path
== NULL
) {
1750 cifs_dbg(FYI
, "Update attributes: %s inode 0x%p count %d dentry: 0x%p d_time %ld jiffies %ld\n",
1751 full_path
, inode
, inode
->i_count
.counter
,
1752 dentry
, dentry
->d_time
, jiffies
);
1754 if (cifs_sb_master_tcon(CIFS_SB(sb
))->unix_ext
)
1755 rc
= cifs_get_inode_info_unix(&inode
, full_path
, sb
, xid
);
1757 rc
= cifs_get_inode_info(&inode
, full_path
, NULL
, sb
,
1766 int cifs_revalidate_file(struct file
*filp
)
1769 struct inode
*inode
= file_inode(filp
);
1771 rc
= cifs_revalidate_file_attr(filp
);
1775 if (CIFS_I(inode
)->invalid_mapping
)
1776 rc
= cifs_invalidate_mapping(inode
);
1780 /* revalidate a dentry's inode attributes */
1781 int cifs_revalidate_dentry(struct dentry
*dentry
)
1784 struct inode
*inode
= dentry
->d_inode
;
1786 rc
= cifs_revalidate_dentry_attr(dentry
);
1790 if (CIFS_I(inode
)->invalid_mapping
)
1791 rc
= cifs_invalidate_mapping(inode
);
1795 int cifs_getattr(struct vfsmount
*mnt
, struct dentry
*dentry
,
1798 struct cifs_sb_info
*cifs_sb
= CIFS_SB(dentry
->d_sb
);
1799 struct cifs_tcon
*tcon
= cifs_sb_master_tcon(cifs_sb
);
1800 struct inode
*inode
= dentry
->d_inode
;
1804 * We need to be sure that all dirty pages are written and the server
1805 * has actual ctime, mtime and file length.
1807 if (!CIFS_CACHE_READ(CIFS_I(inode
)) && inode
->i_mapping
&&
1808 inode
->i_mapping
->nrpages
!= 0) {
1809 rc
= filemap_fdatawait(inode
->i_mapping
);
1811 mapping_set_error(inode
->i_mapping
, rc
);
1816 rc
= cifs_revalidate_dentry_attr(dentry
);
1820 generic_fillattr(inode
, stat
);
1821 stat
->blksize
= CIFS_MAX_MSGSIZE
;
1822 stat
->ino
= CIFS_I(inode
)->uniqueid
;
1825 * If on a multiuser mount without unix extensions or cifsacl being
1826 * enabled, and the admin hasn't overridden them, set the ownership
1827 * to the fsuid/fsgid of the current process.
1829 if ((cifs_sb
->mnt_cifs_flags
& CIFS_MOUNT_MULTIUSER
) &&
1830 !(cifs_sb
->mnt_cifs_flags
& CIFS_MOUNT_CIFS_ACL
) &&
1832 if (!(cifs_sb
->mnt_cifs_flags
& CIFS_MOUNT_OVERR_UID
))
1833 stat
->uid
= current_fsuid();
1834 if (!(cifs_sb
->mnt_cifs_flags
& CIFS_MOUNT_OVERR_GID
))
1835 stat
->gid
= current_fsgid();
1840 static int cifs_truncate_page(struct address_space
*mapping
, loff_t from
)
1842 pgoff_t index
= from
>> PAGE_CACHE_SHIFT
;
1843 unsigned offset
= from
& (PAGE_CACHE_SIZE
- 1);
1847 page
= grab_cache_page(mapping
, index
);
1851 zero_user_segment(page
, offset
, PAGE_CACHE_SIZE
);
1853 page_cache_release(page
);
1857 static void cifs_setsize(struct inode
*inode
, loff_t offset
)
1859 spin_lock(&inode
->i_lock
);
1860 i_size_write(inode
, offset
);
1861 spin_unlock(&inode
->i_lock
);
1863 truncate_pagecache(inode
, offset
);
1867 cifs_set_file_size(struct inode
*inode
, struct iattr
*attrs
,
1868 unsigned int xid
, char *full_path
)
1871 struct cifsFileInfo
*open_file
;
1872 struct cifsInodeInfo
*cifsInode
= CIFS_I(inode
);
1873 struct cifs_sb_info
*cifs_sb
= CIFS_SB(inode
->i_sb
);
1874 struct tcon_link
*tlink
= NULL
;
1875 struct cifs_tcon
*tcon
= NULL
;
1876 struct TCP_Server_Info
*server
;
1877 struct cifs_io_parms io_parms
;
1880 * To avoid spurious oplock breaks from server, in the case of
1881 * inodes that we already have open, avoid doing path based
1882 * setting of file size if we can do it by handle.
1883 * This keeps our caching token (oplock) and avoids timeouts
1884 * when the local oplock break takes longer to flush
1885 * writebehind data than the SMB timeout for the SetPathInfo
1886 * request would allow
1888 open_file
= find_writable_file(cifsInode
, true);
1890 tcon
= tlink_tcon(open_file
->tlink
);
1891 server
= tcon
->ses
->server
;
1892 if (server
->ops
->set_file_size
)
1893 rc
= server
->ops
->set_file_size(xid
, tcon
, open_file
,
1894 attrs
->ia_size
, false);
1897 cifsFileInfo_put(open_file
);
1898 cifs_dbg(FYI
, "SetFSize for attrs rc = %d\n", rc
);
1899 if ((rc
== -EINVAL
) || (rc
== -EOPNOTSUPP
)) {
1900 unsigned int bytes_written
;
1902 io_parms
.netfid
= open_file
->fid
.netfid
;
1903 io_parms
.pid
= open_file
->pid
;
1904 io_parms
.tcon
= tcon
;
1905 io_parms
.offset
= 0;
1906 io_parms
.length
= attrs
->ia_size
;
1907 rc
= CIFSSMBWrite(xid
, &io_parms
, &bytes_written
,
1909 cifs_dbg(FYI
, "Wrt seteof rc %d\n", rc
);
1918 tlink
= cifs_sb_tlink(cifs_sb
);
1920 return PTR_ERR(tlink
);
1921 tcon
= tlink_tcon(tlink
);
1922 server
= tcon
->ses
->server
;
1926 * Set file size by pathname rather than by handle either because no
1927 * valid, writeable file handle for it was found or because there was
1928 * an error setting it by handle.
1930 if (server
->ops
->set_path_size
)
1931 rc
= server
->ops
->set_path_size(xid
, tcon
, full_path
,
1932 attrs
->ia_size
, cifs_sb
, false);
1935 cifs_dbg(FYI
, "SetEOF by path (setattrs) rc = %d\n", rc
);
1936 if ((rc
== -EINVAL
) || (rc
== -EOPNOTSUPP
)) {
1940 rc
= SMBLegacyOpen(xid
, tcon
, full_path
, FILE_OPEN
,
1941 GENERIC_WRITE
, CREATE_NOT_DIR
, &netfid
,
1942 &oplock
, NULL
, cifs_sb
->local_nls
,
1943 cifs_sb
->mnt_cifs_flags
&
1944 CIFS_MOUNT_MAP_SPECIAL_CHR
);
1946 unsigned int bytes_written
;
1948 io_parms
.netfid
= netfid
;
1949 io_parms
.pid
= current
->tgid
;
1950 io_parms
.tcon
= tcon
;
1951 io_parms
.offset
= 0;
1952 io_parms
.length
= attrs
->ia_size
;
1953 rc
= CIFSSMBWrite(xid
, &io_parms
, &bytes_written
, NULL
,
1955 cifs_dbg(FYI
, "wrt seteof rc %d\n", rc
);
1956 CIFSSMBClose(xid
, tcon
, netfid
);
1960 cifs_put_tlink(tlink
);
1964 cifsInode
->server_eof
= attrs
->ia_size
;
1965 cifs_setsize(inode
, attrs
->ia_size
);
1966 cifs_truncate_page(inode
->i_mapping
, inode
->i_size
);
1973 cifs_setattr_unix(struct dentry
*direntry
, struct iattr
*attrs
)
1977 char *full_path
= NULL
;
1978 struct inode
*inode
= direntry
->d_inode
;
1979 struct cifsInodeInfo
*cifsInode
= CIFS_I(inode
);
1980 struct cifs_sb_info
*cifs_sb
= CIFS_SB(inode
->i_sb
);
1981 struct tcon_link
*tlink
;
1982 struct cifs_tcon
*pTcon
;
1983 struct cifs_unix_set_info_args
*args
= NULL
;
1984 struct cifsFileInfo
*open_file
;
1986 cifs_dbg(FYI
, "setattr_unix on file %s attrs->ia_valid=0x%x\n",
1987 direntry
->d_name
.name
, attrs
->ia_valid
);
1991 if (cifs_sb
->mnt_cifs_flags
& CIFS_MOUNT_NO_PERM
)
1992 attrs
->ia_valid
|= ATTR_FORCE
;
1994 rc
= inode_change_ok(inode
, attrs
);
1998 full_path
= build_path_from_dentry(direntry
);
1999 if (full_path
== NULL
) {
2005 * Attempt to flush data before changing attributes. We need to do
2006 * this for ATTR_SIZE and ATTR_MTIME for sure, and if we change the
2007 * ownership or mode then we may also need to do this. Here, we take
2008 * the safe way out and just do the flush on all setattr requests. If
2009 * the flush returns error, store it to report later and continue.
2011 * BB: This should be smarter. Why bother flushing pages that
2012 * will be truncated anyway? Also, should we error out here if
2013 * the flush returns error?
2015 rc
= filemap_write_and_wait(inode
->i_mapping
);
2016 mapping_set_error(inode
->i_mapping
, rc
);
2019 if (attrs
->ia_valid
& ATTR_SIZE
) {
2020 rc
= cifs_set_file_size(inode
, attrs
, xid
, full_path
);
2025 /* skip mode change if it's just for clearing setuid/setgid */
2026 if (attrs
->ia_valid
& (ATTR_KILL_SUID
|ATTR_KILL_SGID
))
2027 attrs
->ia_valid
&= ~ATTR_MODE
;
2029 args
= kmalloc(sizeof(*args
), GFP_KERNEL
);
2035 /* set up the struct */
2036 if (attrs
->ia_valid
& ATTR_MODE
)
2037 args
->mode
= attrs
->ia_mode
;
2039 args
->mode
= NO_CHANGE_64
;
2041 if (attrs
->ia_valid
& ATTR_UID
)
2042 args
->uid
= attrs
->ia_uid
;
2044 args
->uid
= INVALID_UID
; /* no change */
2046 if (attrs
->ia_valid
& ATTR_GID
)
2047 args
->gid
= attrs
->ia_gid
;
2049 args
->gid
= INVALID_GID
; /* no change */
2051 if (attrs
->ia_valid
& ATTR_ATIME
)
2052 args
->atime
= cifs_UnixTimeToNT(attrs
->ia_atime
);
2054 args
->atime
= NO_CHANGE_64
;
2056 if (attrs
->ia_valid
& ATTR_MTIME
)
2057 args
->mtime
= cifs_UnixTimeToNT(attrs
->ia_mtime
);
2059 args
->mtime
= NO_CHANGE_64
;
2061 if (attrs
->ia_valid
& ATTR_CTIME
)
2062 args
->ctime
= cifs_UnixTimeToNT(attrs
->ia_ctime
);
2064 args
->ctime
= NO_CHANGE_64
;
2067 open_file
= find_writable_file(cifsInode
, true);
2069 u16 nfid
= open_file
->fid
.netfid
;
2070 u32 npid
= open_file
->pid
;
2071 pTcon
= tlink_tcon(open_file
->tlink
);
2072 rc
= CIFSSMBUnixSetFileInfo(xid
, pTcon
, args
, nfid
, npid
);
2073 cifsFileInfo_put(open_file
);
2075 tlink
= cifs_sb_tlink(cifs_sb
);
2076 if (IS_ERR(tlink
)) {
2077 rc
= PTR_ERR(tlink
);
2080 pTcon
= tlink_tcon(tlink
);
2081 rc
= CIFSSMBUnixSetPathInfo(xid
, pTcon
, full_path
, args
,
2083 cifs_sb
->mnt_cifs_flags
&
2084 CIFS_MOUNT_MAP_SPECIAL_CHR
);
2085 cifs_put_tlink(tlink
);
2091 if ((attrs
->ia_valid
& ATTR_SIZE
) &&
2092 attrs
->ia_size
!= i_size_read(inode
))
2093 truncate_setsize(inode
, attrs
->ia_size
);
2095 setattr_copy(inode
, attrs
);
2096 mark_inode_dirty(inode
);
2098 /* force revalidate when any of these times are set since some
2099 of the fs types (eg ext3, fat) do not have fine enough
2100 time granularity to match protocol, and we do not have a
2101 a way (yet) to query the server fs's time granularity (and
2102 whether it rounds times down).
2104 if (attrs
->ia_valid
& (ATTR_MTIME
| ATTR_CTIME
))
2105 cifsInode
->time
= 0;
2114 cifs_setattr_nounix(struct dentry
*direntry
, struct iattr
*attrs
)
2117 kuid_t uid
= INVALID_UID
;
2118 kgid_t gid
= INVALID_GID
;
2119 struct inode
*inode
= direntry
->d_inode
;
2120 struct cifs_sb_info
*cifs_sb
= CIFS_SB(inode
->i_sb
);
2121 struct cifsInodeInfo
*cifsInode
= CIFS_I(inode
);
2122 char *full_path
= NULL
;
2125 __u64 mode
= NO_CHANGE_64
;
2129 cifs_dbg(FYI
, "setattr on file %s attrs->iavalid 0x%x\n",
2130 direntry
->d_name
.name
, attrs
->ia_valid
);
2132 if (cifs_sb
->mnt_cifs_flags
& CIFS_MOUNT_NO_PERM
)
2133 attrs
->ia_valid
|= ATTR_FORCE
;
2135 rc
= inode_change_ok(inode
, attrs
);
2141 full_path
= build_path_from_dentry(direntry
);
2142 if (full_path
== NULL
) {
2149 * Attempt to flush data before changing attributes. We need to do
2150 * this for ATTR_SIZE and ATTR_MTIME for sure, and if we change the
2151 * ownership or mode then we may also need to do this. Here, we take
2152 * the safe way out and just do the flush on all setattr requests. If
2153 * the flush returns error, store it to report later and continue.
2155 * BB: This should be smarter. Why bother flushing pages that
2156 * will be truncated anyway? Also, should we error out here if
2157 * the flush returns error?
2159 rc
= filemap_write_and_wait(inode
->i_mapping
);
2160 mapping_set_error(inode
->i_mapping
, rc
);
2163 if (attrs
->ia_valid
& ATTR_SIZE
) {
2164 rc
= cifs_set_file_size(inode
, attrs
, xid
, full_path
);
2166 goto cifs_setattr_exit
;
2169 if (attrs
->ia_valid
& ATTR_UID
)
2170 uid
= attrs
->ia_uid
;
2172 if (attrs
->ia_valid
& ATTR_GID
)
2173 gid
= attrs
->ia_gid
;
2175 #ifdef CONFIG_CIFS_ACL
2176 if (cifs_sb
->mnt_cifs_flags
& CIFS_MOUNT_CIFS_ACL
) {
2177 if (uid_valid(uid
) || gid_valid(gid
)) {
2178 rc
= id_mode_to_cifs_acl(inode
, full_path
, NO_CHANGE_64
,
2181 cifs_dbg(FYI
, "%s: Setting id failed with error: %d\n",
2183 goto cifs_setattr_exit
;
2187 #endif /* CONFIG_CIFS_ACL */
2188 if (!(cifs_sb
->mnt_cifs_flags
& CIFS_MOUNT_SET_UID
))
2189 attrs
->ia_valid
&= ~(ATTR_UID
| ATTR_GID
);
2191 /* skip mode change if it's just for clearing setuid/setgid */
2192 if (attrs
->ia_valid
& (ATTR_KILL_SUID
|ATTR_KILL_SGID
))
2193 attrs
->ia_valid
&= ~ATTR_MODE
;
2195 if (attrs
->ia_valid
& ATTR_MODE
) {
2196 mode
= attrs
->ia_mode
;
2198 #ifdef CONFIG_CIFS_ACL
2199 if (cifs_sb
->mnt_cifs_flags
& CIFS_MOUNT_CIFS_ACL
) {
2200 rc
= id_mode_to_cifs_acl(inode
, full_path
, mode
,
2201 INVALID_UID
, INVALID_GID
);
2203 cifs_dbg(FYI
, "%s: Setting ACL failed with error: %d\n",
2205 goto cifs_setattr_exit
;
2208 #endif /* CONFIG_CIFS_ACL */
2209 if (((mode
& S_IWUGO
) == 0) &&
2210 (cifsInode
->cifsAttrs
& ATTR_READONLY
) == 0) {
2212 dosattr
= cifsInode
->cifsAttrs
| ATTR_READONLY
;
2214 /* fix up mode if we're not using dynperm */
2215 if ((cifs_sb
->mnt_cifs_flags
& CIFS_MOUNT_DYNPERM
) == 0)
2216 attrs
->ia_mode
= inode
->i_mode
& ~S_IWUGO
;
2217 } else if ((mode
& S_IWUGO
) &&
2218 (cifsInode
->cifsAttrs
& ATTR_READONLY
)) {
2220 dosattr
= cifsInode
->cifsAttrs
& ~ATTR_READONLY
;
2221 /* Attributes of 0 are ignored */
2223 dosattr
|= ATTR_NORMAL
;
2225 /* reset local inode permissions to normal */
2226 if (!(cifs_sb
->mnt_cifs_flags
& CIFS_MOUNT_DYNPERM
)) {
2227 attrs
->ia_mode
&= ~(S_IALLUGO
);
2228 if (S_ISDIR(inode
->i_mode
))
2230 cifs_sb
->mnt_dir_mode
;
2233 cifs_sb
->mnt_file_mode
;
2235 } else if (!(cifs_sb
->mnt_cifs_flags
& CIFS_MOUNT_DYNPERM
)) {
2236 /* ignore mode change - ATTR_READONLY hasn't changed */
2237 attrs
->ia_valid
&= ~ATTR_MODE
;
2241 if (attrs
->ia_valid
& (ATTR_MTIME
|ATTR_ATIME
|ATTR_CTIME
) ||
2242 ((attrs
->ia_valid
& ATTR_MODE
) && dosattr
)) {
2243 rc
= cifs_set_file_info(inode
, attrs
, xid
, full_path
, dosattr
);
2244 /* BB: check for rc = -EOPNOTSUPP and switch to legacy mode */
2246 /* Even if error on time set, no sense failing the call if
2247 the server would set the time to a reasonable value anyway,
2248 and this check ensures that we are not being called from
2249 sys_utimes in which case we ought to fail the call back to
2250 the user when the server rejects the call */
2251 if ((rc
) && (attrs
->ia_valid
&
2252 (ATTR_MODE
| ATTR_GID
| ATTR_UID
| ATTR_SIZE
)))
2256 /* do not need local check to inode_check_ok since the server does
2259 goto cifs_setattr_exit
;
2261 if ((attrs
->ia_valid
& ATTR_SIZE
) &&
2262 attrs
->ia_size
!= i_size_read(inode
))
2263 truncate_setsize(inode
, attrs
->ia_size
);
2265 setattr_copy(inode
, attrs
);
2266 mark_inode_dirty(inode
);
2275 cifs_setattr(struct dentry
*direntry
, struct iattr
*attrs
)
2277 struct inode
*inode
= direntry
->d_inode
;
2278 struct cifs_sb_info
*cifs_sb
= CIFS_SB(inode
->i_sb
);
2279 struct cifs_tcon
*pTcon
= cifs_sb_master_tcon(cifs_sb
);
2281 if (pTcon
->unix_ext
)
2282 return cifs_setattr_unix(direntry
, attrs
);
2284 return cifs_setattr_nounix(direntry
, attrs
);
2286 /* BB: add cifs_setattr_legacy for really old servers */
2290 void cifs_delete_inode(struct inode
*inode
)
2292 cifs_dbg(FYI
, "In cifs_delete_inode, inode = 0x%p\n", inode
);
2293 /* may have to add back in if and when safe distributed caching of
2294 directories added e.g. via FindNotify */