source: branches/samba-3.2.x/source/smbd/dfree.c@ 715

Last change on this file since 715 was 133, checked in by Paul Smedley, 17 years ago

Update trunk to 3.2.0pre3
File size: 5.9 KB
Line 
1/*
2 Unix SMB/CIFS implementation.
3 functions to calculate the free disk space
4 Copyright (C) Andrew Tridgell 1998
5
6 This program is free software; you can redistribute it and/or modify
7 it under the terms of the GNU General Public License as published by
8 the Free Software Foundation; either version 3 of the License, or
9 (at your option) any later version.
10
11 This program is distributed in the hope that it will be useful,
12 but WITHOUT ANY WARRANTY; without even the implied warranty of
13 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14 GNU General Public License for more details.
15
16 You should have received a copy of the GNU General Public License
17 along with this program. If not, see <http://www.gnu.org/licenses/>.
18*/
19
20#include "includes.h"
21
22/****************************************************************************
23 Normalise for DOS usage.
24****************************************************************************/
25
26static void disk_norm(bool small_query, SMB_BIG_UINT *bsize,SMB_BIG_UINT *dfree,SMB_BIG_UINT *dsize)
27{
28 /* check if the disk is beyond the max disk size */
29 SMB_BIG_UINT maxdisksize = lp_maxdisksize();
30 if (maxdisksize) {
31 /* convert to blocks - and don't overflow */
32 maxdisksize = ((maxdisksize*1024)/(*bsize))*1024;
33 if (*dsize > maxdisksize) *dsize = maxdisksize;
34 if (*dfree > maxdisksize) *dfree = maxdisksize-1;
35 /* the -1 should stop applications getting div by 0
36 errors */
37 }
38
39 if(small_query) {
40 while (*dfree > WORDMAX || *dsize > WORDMAX || *bsize < 512) {
41 *dfree /= 2;
42 *dsize /= 2;
43 *bsize *= 2;
44 /*
45 * Force max to fit in 16 bit fields.
46 */
47 if (*bsize > (WORDMAX*512)) {
48 *bsize = (WORDMAX*512);
49 if (*dsize > WORDMAX)
50 *dsize = WORDMAX;
51 if (*dfree > WORDMAX)
52 *dfree = WORDMAX;
53 break;
54 }
55 }
56 }
57}
58
59
60
61/****************************************************************************
62 Return number of 1K blocks available on a path and total number.
63****************************************************************************/
64
65SMB_BIG_UINT sys_disk_free(connection_struct *conn, const char *path, bool small_query,
66 SMB_BIG_UINT *bsize,SMB_BIG_UINT *dfree,SMB_BIG_UINT *dsize)
67{
68 SMB_BIG_UINT dfree_retval;
69 SMB_BIG_UINT dfree_q = 0;
70 SMB_BIG_UINT bsize_q = 0;
71 SMB_BIG_UINT dsize_q = 0;
72 const char *dfree_command;
73
74 (*dfree) = (*dsize) = 0;
75 (*bsize) = 512;
76
77 /*
78 * If external disk calculation specified, use it.
79 */
80
81 dfree_command = lp_dfree_command(SNUM(conn));
82 if (dfree_command && *dfree_command) {
83 const char *p;
84 char **lines = NULL;
85 char *syscmd = NULL;
86
87 syscmd = talloc_asprintf(talloc_tos(),
88 "%s %s",
89 dfree_command,
90 path);
91
92 if (!syscmd) {
93 return (SMB_BIG_UINT)-1;
94 }
95
96 DEBUG (3, ("disk_free: Running command %s\n", syscmd));
97
98 lines = file_lines_pload(syscmd, NULL);
99 if (lines) {
100 char *line = lines[0];
101
102 DEBUG (3, ("Read input from dfree, \"%s\"\n", line));
103
104 *dsize = STR_TO_SMB_BIG_UINT(line, &p);
105 while (p && *p && isspace(*p))
106 p++;
107 if (p && *p)
108 *dfree = STR_TO_SMB_BIG_UINT(p, &p);
109 while (p && *p && isspace(*p))
110 p++;
111 if (p && *p)
112 *bsize = STR_TO_SMB_BIG_UINT(p, NULL);
113 else
114 *bsize = 1024;
115 file_lines_free(lines);
116 DEBUG (3, ("Parsed output of dfree, dsize=%u, dfree=%u, bsize=%u\n",
117 (unsigned int)*dsize, (unsigned int)*dfree, (unsigned int)*bsize));
118
119 if (!*dsize)
120 *dsize = 2048;
121 if (!*dfree)
122 *dfree = 1024;
123 } else {
124 DEBUG (0, ("disk_free: sys_popen() failed for command %s. Error was : %s\n",
125 syscmd, strerror(errno) ));
126 if (sys_fsusage(path, dfree, dsize) != 0) {
127 DEBUG (0, ("disk_free: sys_fsusage() failed. Error was : %s\n",
128 strerror(errno) ));
129 return (SMB_BIG_UINT)-1;
130 }
131 }
132 } else {
133 if (sys_fsusage(path, dfree, dsize) != 0) {
134 DEBUG (0, ("disk_free: sys_fsusage() failed. Error was : %s\n",
135 strerror(errno) ));
136 return (SMB_BIG_UINT)-1;
137 }
138 }
139
140 if (disk_quotas(path, &bsize_q, &dfree_q, &dsize_q)) {
141 (*bsize) = bsize_q;
142 (*dfree) = MIN(*dfree,dfree_q);
143 (*dsize) = MIN(*dsize,dsize_q);
144 }
145
146 /* FIXME : Any reason for this assumption ? */
147 if (*bsize < 256) {
148 DEBUG(5,("disk_free:Warning: bsize == %d < 256 . Changing to assumed correct bsize = 512\n",(int)*bsize));
149 *bsize = 512;
150 }
151
152 if ((*dsize)<1) {
153 static bool done = false;
154 if (!done) {
155 DEBUG(0,("WARNING: dfree is broken on this system\n"));
156 done=true;
157 }
158 *dsize = 20*1024*1024/(*bsize);
159 *dfree = MAX(1,*dfree);
160 }
161
162 disk_norm(small_query,bsize,dfree,dsize);
163
164 if ((*bsize) < 1024) {
165 dfree_retval = (*dfree)/(1024/(*bsize));
166 } else {
167 dfree_retval = ((*bsize)/1024)*(*dfree);
168 }
169
170 return(dfree_retval);
171}
172
173/****************************************************************************
174 Potentially returned cached dfree info.
175****************************************************************************/
176
177SMB_BIG_UINT get_dfree_info(connection_struct *conn,
178 const char *path,
179 bool small_query,
180 SMB_BIG_UINT *bsize,
181 SMB_BIG_UINT *dfree,
182 SMB_BIG_UINT *dsize)
183{
184 int dfree_cache_time = lp_dfree_cache_time(SNUM(conn));
185 struct dfree_cached_info *dfc = conn->dfree_info;
186 SMB_BIG_UINT dfree_ret;
187
188 if (!dfree_cache_time) {
189 return SMB_VFS_DISK_FREE(conn,path,small_query,bsize,dfree,dsize);
190 }
191
192 if (dfc && (conn->lastused - dfc->last_dfree_time < dfree_cache_time)) {
193 /* Return cached info. */
194 *bsize = dfc->bsize;
195 *dfree = dfc->dfree;
196 *dsize = dfc->dsize;
197 return dfc->dfree_ret;
198 }
199
200 dfree_ret = SMB_VFS_DISK_FREE(conn,path,small_query,bsize,dfree,dsize);
201
202 if (dfree_ret == (SMB_BIG_UINT)-1) {
203 /* Don't cache bad data. */
204 return dfree_ret;
205 }
206
207 /* No cached info or time to refresh. */
208 if (!dfc) {
209 dfc = TALLOC_P(conn->mem_ctx, struct dfree_cached_info);
210 if (!dfc) {
211 return dfree_ret;
212 }
213 conn->dfree_info = dfc;
214 }
215
216 dfc->bsize = *bsize;
217 dfc->dfree = *dfree;
218 dfc->dsize = *dsize;
219 dfc->dfree_ret = dfree_ret;
220 dfc->last_dfree_time = conn->lastused;
221
222 return dfree_ret;
223}
Note: See TracBrowser for help on using the repository browser.